– Dispositivos BMP (por exemplo, roteadores) enviam mensagens BMP para um coletor/daemon OpenBMP. Um daemon OpenBMP pode lidar com muitos roteadores e peers bgp, mas em uma rede grande com links de trânsito e tabelas de roteamento de internet completas, vários coletores OpenBMP são recomendados. Basta configurar no dispositivo BMP (roteador) qual servidor BMP deve ser utilizado.

– O Kafka permite que muitos aplicativos acessem os feeds BMP existentes de qualquer número de roteadores. Um único feed BMP via OpenBMP pode alimentar centenas de aplicativos de consumo, como MySQL, Cassandra, monitores em tempo real, arquivo simples, ELK, Apache Spark, etc.

– Administradores, engenheiros de rede, programas/scripts automatizados, etc. interagem com a API OpenBMP ou qualquer outro aplicativo de consumo

Casos de uso

(Tradução de: https://www.openbmp.org)
Existem muitas razões para usar o OpenBMP, mas para destacar algumas comuns:

– Coletor BMP Centralizado – OpenBMP é um produtor para Kafka. Você pode escrever seu próprio consumidor ou usar um existente. Outros produtos podem interagir com o OpenBMP via Apache Kafka para fluxos RAW BMP ou as mensagens analisadas. Consulte Especificação da API do Barramento de Mensagens para obter mais detalhes.

– Monitoramento de topologia em tempo real – Pode monitorar e alertar sobre alterações de topologia, alterações de política ou falta de aplicação, vazamento de rota, seqüestro, etc.

– Segurança de BGP/Rota – Vazamento de rota, seqüestro por origem, por melhores caminhos de trânsito ou desvio da linha de base

– Espelhos – IPv4, IPv6 e VPN4

– Route Analytics – Rastreie tempos de convergência, histórico de prefixos conforme eles mudam ao longo do tempo, monitore e rastreie mudanças de política BGP, etc…

– Análise de Engenharia de Tráfego – Adapte-se dinamicamente às mudanças e saiba qual é a melhor mudança

– Hipóteses pré-políticas de BGP – As informações de roteamento pré-políticas fornecem informações sobre todos os atributos de caminho de vários pontos na rede, permitindo visualizações de topologia hipotéticas não intrusivas para novas validações de políticas

– Topologia IGP – BGP-LS (link-state) fornece a topologia completa do IGP (OSPF e/ou IS-IS). A topologia IGP fornece informações de nível de nó, link e prefixo. Isso inclui todos os próximos saltos do BGP. Agora é possível fazer uma seleção de melhor caminho BGP com métrica IGP para informações Adj-In-RIB. Também é possível monitorar o próprio IGP no que se refere a links, nós, prefixos e BGP.

Quem desejar se aprofundar mais tem um lindo artigo no Brasil Peering Fórum escrito pelo Leonardo Furtado. Agradeço ao Rudson Costa por me apresentar a ferramenta e me instigar a escrever este tutorial.

Distribuição utilizada neste tutorial:
Debian 11 (Bullseye) 64 bits instalação mínima
Como melhorar a produtividade no seu Debian após instalação (Recomendado)

Atualize e instale os pacotes necessários

# apt update -y 
# apt upgrade -y 
# apt install wget git vim nano docker-compose htop tree -y 

Crie o diretório qual iremos baixar o projeto OpenBMP

# mkdir /root/obmp-install
# cd /root/obmp-install
# wget https://raw.githubusercontent.com/OpenBMP/obmp-docker/main/docker-compose.yml 
# git clone https://github.com/OpenBMP/obmp-grafana.git

Crie todos os diretórios e de as devidas permissões (segui a documentação, antes de vir me criticar do 777)

# export OBMP_DATA_ROOT=/var/openbmp
# mkdir -p $OBMP_DATA_ROOT
# mkdir -p ${OBMP_DATA_ROOT}/config
# chmod -R 777 ${OBMP_DATA_ROOT}/config
# mkdir -p ${OBMP_DATA_ROOT}/zk-data
# mkdir -p ${OBMP_DATA_ROOT}/zk-log
# chown -R 1000:1000 ${OBMP_DATA_ROOT}/zk-*/
# mkdir -p ${OBMP_DATA_ROOT}/postgres/data
# mkdir -p ${OBMP_DATA_ROOT}/postgres/ts
# chown -R 1000:1000 ${OBMP_DATA_ROOT}/postgres/
# mkdir -p ${OBMP_DATA_ROOT}/kafka-data
# chown -R 1000:1000 ${OBMP_DATA_ROOT}/kafka-data/
# chmod 777 ${OBMP_DATA_ROOT}/kafka-data
# mkdir -p ${OBMP_DATA_ROOT}/grafana
# cp -r obmp-grafana/dashboards obmp-grafana/provisioning ${OBMP_DATA_ROOT}/grafana/
# chmod -R 777 ${OBMP_DATA_ROOT}/grafana

Verifique se tudo foi criado

# tree $OBMP_DATA_ROOT

Ajuste a memória Psql-App leia mais aqui sobre requisitos de hardware

# sed -i 's/- MEM=3/- MEM=4/' docker-compose.yml

Agora iremos subir todos os containes:

# OBMP_DATA_ROOT=/var/openbmp docker-compose -f ./docker-compose.yml -p obmp up -d

Verifique se todos os containes estão Ups

docker ps

#CONTAINER ID   IMAGE                             COMMAND                  CREATED          STATUS          PORTS                                        NAMES
#079afaaba23f   confluentinc/cp-kafka:7.1.1       "/etc/confluent/dock…"   24 minutes ago   Up 24 minutes   0.0.0.0:9092->9092/tcp                       obmp-kafka
#fc2f5a316138   openbmp/whois:2.2.0               "/bin/sh -c '/usr/lo…"   24 minutes ago   Up 24 minutes   0.0.0.0:4300->43/tcp                         obmp-whois
#47d8776c4fc9   openbmp/psql-app:2.2.1            "/usr/sbin/run"          24 minutes ago   Up 23 minutes   0.0.0.0:9005->9005/tcp                       obmp-psql-app
#9b97cc146ff7   openbmp/postgres:2.2.0            "/docker-entrypoint.…"   24 minutes ago   Up 24 minutes   8008/tcp, 0.0.0.0:5432->5432/tcp, 8081/tcp   obmp-psql
#dc694dd40972   openbmp/collector:2.2.0           "/usr/sbin/run"          24 minutes ago   Up 24 minutes   0.0.0.0:5000->5000/tcp                       obmp-collector
#305a1f316ba8   confluentinc/cp-zookeeper:7.1.1   "/etc/confluent/dock…"   24 minutes ago   Up 24 minutes   2181/tcp, 2888/tcp, 3888/tcp                 obmp-zookeeper
#949272653acb   grafana/grafana:8.5.4             "/run.sh"                24 minutes ago   Up 24 minutes   0.0.0.0:3000->3000/tcp                       obmp-grafana

Acesse o grafana na porta 3000 deslogue e logue novamente com usuário admin e senha openbmp e faça a alteração do mesmo.

Criando um firewall para proteger

Podemos consultar com o comando ss várias portas abertas, por segurança vamos fecha-las.

# ss -putan | grep LIST

tcp   LISTEN 0      128          0.0.0.0:22          0.0.0.0:*     users:(("sshd",pid=441,fd=3))                        
tcp   LISTEN 0      4096         0.0.0.0:5432        0.0.0.0:*     users:(("docker-proxy",pid=5651,fd=4))               
tcp   LISTEN 0      4096         0.0.0.0:3000        0.0.0.0:*     users:(("docker-proxy",pid=5547,fd=4))               
tcp   LISTEN 0      4096         0.0.0.0:9092        0.0.0.0:*     users:(("docker-proxy",pid=6188,fd=4))               
tcp   LISTEN 0      4096         0.0.0.0:5000        0.0.0.0:*     users:(("docker-proxy",pid=5576,fd=4))               
tcp   LISTEN 0      4096       127.0.0.1:42315       0.0.0.0:*     users:(("containerd",pid=429,fd=13))                 
tcp   LISTEN 0      4096         0.0.0.0:4300        0.0.0.0:*     users:(("docker-proxy",pid=5756,fd=4))               
tcp   LISTEN 0      4096         0.0.0.0:9005        0.0.0.0:*     users:(("docker-proxy",pid=6559,fd=4))               
tcp   LISTEN 0      128             [::]:22             [::]:*     users:(("sshd",pid=441,fd=4))  

O nftablesjá vem por padrão instalado no Debian 11.

# vim /etc/nftables.conf

Neste exemplo (quase q auto explicativo) vou deixar apenas a porta do Grafana aberta, as demais restritas a variável ACESSO_EXTERNO.

#!/usr/sbin/nft -f

flush ruleset

define PORTAS_RESTRITAS = { 22,4300,5000,5432,9092,9005 }
define PORTAS_ABERTAS = { 3000 }

define ACESSO_EXTERNO_IPv4 = { 172.16.0.0/12, 10.0.0.0/8, 200.200.200.0/24 }
define ACESSO_EXTERNO_IPv6 = { 2001:db8:1::/64 }

define ACESSO_LOCALHOST_IPv4 = { 127.0.0.0/8 }
define ACESSO_LOCALHOST_IPv6 = { ::1/128 }

table inet filter {
    set src_ipv4 {
        type ipv4_addr
        flags interval
        elements = { $ACESSO_LOCALHOST_IPv4, $ACESSO_EXTERNO_IPv4 }
    }
    set src_ipv6 {
        type ipv6_addr
        flags interval
        elements = { $ACESSO_LOCALHOST_IPv6, $ACESSO_EXTERNO_IPv6 }
    }
    chain input {
        type filter hook input priority 0;
        ip saddr  != @src_ipv4 tcp dport { $PORTAS_RESTRITAS } counter drop
        ip6 saddr != @src_ipv6 tcp dport { $PORTAS_RESTRITAS } counter drop

        tcp dport { $PORTAS_ABERTAS } counter accept
        
    }
    chain forward {
        type filter hook forward priority 0;
    }
    chain output {
        type filter hook output priority 0;
    }
}

Habilite para o boot e reinicie o nftables

# systemctl enable nftables 
# systemctl restart nftables 

Se desejar matar todos os containes rode:

# cd /root/obmp-install
OBMP_DATA_ROOT=/var/openbmp docker-compose -p obmp down

Para apagar tudo:

# rm -rf /var/openbmp

Integração com Huawei

bmp
 #
 bmp-session __IP_SERVIDOR__ alias meuprovedor
 tcp connect port 5000
 #
 monitor public
  route-mode ipv4-family unicast adj-rib-in pre-policy
 #
 monitor peer __IP_SERVIDOR__
#
bgp xxxx
 ipv4-family unicast
 peer __IP_PEER_MONITORADO__ keep-all-routes

Se quiser apoiar o blog e fazer uma doação para o café ficarei muito feliz pelo seu reconhecimento!

Se não puder doar pode deixar seu agradecimento nos comentário também ficarei feliz em saber que ajudei. Se tiver qualquer pergunta deixe-a também. Se preferir entrar em Contato clique aqui.

Abraço!

FONTE: https://www.openbmp.org/

O post BGP Monitoring Protocol (BMP) aprenda a instalar o OpenBMP apareceu primeiro em Remontti.

Para montar o servidor vamos usar um projeto muito simples que basicamente tem 2 arquivos, o PHP Looking Glass qual é um fork do projeto russo hsdn.

Você encontra outros projetos legais também como o da respawner qual o pessoal da BPF já fez tutorial sobre o mesmo.

Características do PHP Looking Glass

Suporte a Telnet e SSH (plink ou sshpass).
Suporte aos roteadores Cisco, MikroTik (RouterOS), Juniper, Huawei (Comware), Quagga (Zebra) e OpenBGPD.
Suppores aos protocolos IPv4 e IPv6.
Conversão automática de IPs em sub-redes usando Merit RADb para MikroTik (http://www.ra.net/).
Desenho do gráfico BGP AS usando o kit de ferramentas GraphViz.
Funciona no php 5.2.0 e superiores.

Para subir o projeto em seu servidor você precisa ter um serviço web como apache por exemplo e PHP basicamente. Você pode subir ele em um servido já em produção, não é necessário criar um servidor apenas para essa finalidade. (Porém fica a seu critério)

Vou trazer uma instalação limpa com base na instalação zerada do Debian 10.

Com Debian instalado vamos instalar os pacotes necessários:

# apt install apache2 apache2-utils sshpass graphviz
# apt install libapache2-mod-php php php-cli php-pear php-gmp php-gd php-bcmath php-mbstring php-curl php-xml php-zip
# pear install Image_GraphViz-1.3.0

Vou colocar o projeto no diretório padrão do apache /var/www/html/, mas você pode criar um domínio virtual para isso ficar muito mais legal e ainda criar um certificado gratuitamente com o Let’s Encrypt

# mkdir /var/www/html/lg
# cd /var/www/html/lg
# apt install wget
# wget https://github.com/remontti/lg/raw/master/htdocs/favicon.ico
# wget https://github.com/remontti/lg/raw/master/htdocs/lg_logo.gif
# wget https://raw.githubusercontent.com/remontti/lg/master/htdocs/index.php
# wget https://raw.githubusercontent.com/remontti/lg/master/htdocs/lg_config.php

Agora basta vocÊ editar o arquivo lg_config.php e alterar os valores das variáveis:

$_CONFIG[‘asn’] – Seu AS para exibição na página LG.
$_CONFIG[‘company’] – Nome da empresa para exibição na página LG.
$_CONFIG[‘logo’] – O logotipo da sua empresa para exibição na página LG.
$_CONFIG[‘color’] – Cor principal dos elementos de design na página LG.

A configuração dos roteadores é especificada em $_CONFIG[‘routers’], no seguinte formato:

$_CONFIG['routers'] = array
(
    'router1' = array
    (
        // Router valores
    ),
    'router2' = array
    (
        // Router valores
    ),
    // etc.
);

No nosso arquivo atual já consta com 3 exemplos sendo um o do IX.BR (SP). Basta você configurar seu roteado seguindo os padrões:

url – Endereço no formato: [ssh|telnet]://[login]:[password]@[host]:[port].
pingtraceurl – Endereço URL para ferramentas de ping e traceroute para roteadores Quagga (ou * FALSE *).
description – Descrição do roteador.
group – Nome do grupo de roteadores (AS) (ou FALSE).
ipv6 – Suporte IPv6? (TRUE ou FALSE).
os – Tipo do Router (ios, mikrotik, quagga, junos, openbgpd, huawei).

Configurações ajustada basta acessar o endereço http://ip-servidor/lg ou se você fez bonitinho via domínio

Curtiu o conteúdo? Quer me ajudar?

Se quiser fazer uma doação para o café ficarei muito feliz pelo seu reconhecimento! (Esse deu trabalho!)

Se não puder doar pode deixar seu agradecimento nos comentário também ficarei feliz em saber que ajudei. Se tiver qualquer pergunta deixe-a também. Se preferir entrar em Contato clique aqui.

Participe do canal no telegram para ficar atualizado sempre que publicar um novo tutorial.

Abraço!

Demos
http://dev.hsdn.org/lg/
http://lg.campus-rv.net/
http://lg.lankabell.com/

Gráfico da demonstração (BGP AS)
http://dev.hsdn.org/lg/?command=graph&protocol=ipv4&query=8.8.8.8&router=example1

O post Servidor Looking Glass simples e rápido! apareceu primeiro em Remontti.