BGP Monitoring Protocol (BMP) aprenda a instalar o OpenBMP

openBMP é um sistema de monitoramento BGP. Compatível com protocolo de monitoramento BGP (BMP). Os dados BGP são armazenados no banco de dados PostgreSQL. Os RIBs são mantidos pelo estado, bem como o histórico completo para cada atualização do BGP.

– 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/