Patrick Brandão

Observium: Monitoramento SNMP

Saudações.

Vou ensinar como instalar o Observium para monitoramento SNMP de ativos de rede.

O Observium não substitui Zabbix, Grafana, RaviMonitor, PRTG ou qualquer outro sistema de monitoramento para NOC.

O foco dele não é servir de base para alertas e reações, ele é focado em INVENTÁRIO.

Com o Observium você consegue acompanhar tudo que há na rede e acompanhar a evolução de uso dos recursos.

Pré-requisitos:

  • Linux com Docker;
  • Acesso à Internet durante os procedimentos de instalação;
  • Acesso aos equipamentos a serem monitorados via SNMP;

1 – Preparativos no Docker

Instale o Docker previamente.

Precisamos configurar:

  • Rede Docker chamada network_public para colocar os containers em rede;

Iremos instalar:

  • Traefik (opcional): proxy reverso com TLS/SSL automático usando LetsEncrypt;
  • MariaDB: banco de dados SQL exigido pelo Observium;
  • Observium: usaremos a imagem do Observium produzido pela TMSoft;

1.1 – Rede Docker

Vou deixar dois exemplos, o primeiro apenas com IPv4, se você está em um ambiente neandertal ou paleolítico.

Rede Docker IPv4-Only
Bash
# Rede de containers
    # - Se ja existe, 
    if [ -d /sys/class/net/br-net-public ]; then
        echo "# Rede ja existe";
    else
        echo "# Criando rede docker IPv4-Only";
        # - Criar
        docker network create \
            -d bridge \
            \
            -o "com.docker.network.bridge.name"="br-net-public" \
            -o "com.docker.network.bridge.enable_icc"="true" \
            -o "com.docker.network.driver.mtu"="1500" \
            \
            --subnet 10.249.0.0/16 --gateway 10.249.255.254 \
            \
            network_public;
    fi;
Rede Docker IPv4 e IPv6 (dual-stack)
Bash
# Rede de containers
    # - Se ja existe, 
    if [ -d /sys/class/net/br-net-public ]; then
        echo "# Rede ja existe";
    else
        echo "# Criando rede docker IPv4 e IPv6 (dual-stack)";
        # - Criar
        docker network create \
            -d bridge \
            \
            -o "com.docker.network.bridge.name"="br-net-public" \
            -o "com.docker.network.bridge.enable_icc"="true" \
            -o "com.docker.network.driver.mtu"="1500" \
            \
            --subnet 10.249.0.0/16 --gateway 10.249.255.254 \
            \
            --ipv6 \
            --subnet=2001:db8:10:249::/64 \
            --gateway=2001:db8:10:249::254 \
            \
            network_public;
    fi;

1.2 – Instalando Traefik (opcional)

O Traefik será nosso proxy-reverso para dar URLs públicas para o container.

Você precisará informar seu email para que o LetsEncrypt aceite gerar certificados e alerte de expirações e bloqueios.

Grave seu email no arquivo /etc/email para deixar o script abaixo 100% automático.

Bash

# Email do administrador
echo "seu-nome-ou-nick@dominio-aqui.com.br" > /etc/email;

Rodando Traefik:

Bash
# Variaveis
    NAME=traefik-app;
    LOCAL=$NAME.intranet.br;
    JSONPATH="/etc/letsencrypt/acme.json";
    EMAIL="root@intranet.br";
    [ -f /etc/email ] && EMAIL=$(head -1 /etc/email);

# Imagem
    IMAGE=traefik:latest;
    docker pull $IMAGE;

# Diretorio de dados persistentes
    DATADIR=/storage/traefik-app;
    mkdir -p $DATADIR/letsencrypt;
    mkdir -p $DATADIR/logs;
    mkdir -p $DATADIR/config;

# Renovar/rodar:
    # (limitar a 8 nucleos: --cpus="8.0")
    docker rm -f $NAME 2>/dev/null;
    docker run \
        -d --restart=always \
        --name $NAME -h $LOCAL \
        --tmpfs /run:rw,noexec,nosuid,size=2m \
        --tmpfs /tmp:rw,noexec,nosuid,size=2m \
        --read-only \
        --memory=1g --memory-swap=1g \
        \
        --network network_public \
        --mac-address "02:c2:49:25:55:ff" \
        \
        -p 80:80 \
        -p 443:443 \
        \
        -v /var/run/docker.sock:/var/run/docker.sock:ro \
        -v $DATADIR/letsencrypt:/etc/letsencrypt \
        -v $DATADIR/config:/etc/traefik \
        -v $DATADIR/logs:/logs \
        \
        $IMAGE \
          \
          --global.checkNewVersion=false \
          --global.sendAnonymousUsage=false \
          \
          --api.insecure=true \
          \
          --log.level=INFO \
          --log.filePath=/logs/error.log \
          \
          --accessLog.filePath=/logs/access.log \
          \
          --entrypoints.web.address=:80 \
          --entrypoints.web.http.redirections.entryPoint.to=websecure \
          --entrypoints.web.http.redirections.entryPoint.scheme=https \
          --entrypoints.web.http.redirections.entryPoint.permanent=true \
          --entrypoints.websecure.address=:443 \
          \
          --providers.docker=true \
          --providers.file.directory=/etc/traefik \
          \
          --certificatesresolvers.letsencrypt.acme.email=$EMAIL \
          --certificatesresolvers.letsencrypt.acme.storage=$JSONPATH \
          --certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web;

2 – Instalando o Observium no Docker

2.1 – Instalando MariaDB

O MariaDB (fork do MySQL Server) é a base dos cadastros e informações do Traefik.

Bash
# Variaveis
    NAME="mariadb-main";
    LOCAL="$NAME.intranet.br";
    IMAGE=mariadb:latest;

    # Pasta de persistencia
    DATADIR=/storage/$NAME;
    mkdir -p $DATADIR;

    # banco de dados vazio inicial
    DATABASE=observium;

    # senha padrao
    ROOT_PASSWORD="tulipasql";
    
    USER_NAME="observium";
    USER_PASSWORD="ObsMonit7712";

# Renovar/rodar:
    docker rm -f $NAME 2>/dev/null;
    docker pull mariadb:latest;
    docker run \
        -d --restart=always \
        --name $NAME -h $LOCAL \
        \
        --network network_public \
        --mac-address "02:c2:49:25:55:01" \
        \
        -e "MYSQL_ROOT_PASSWORD=$ROOT_PASSWORD" \
        -e "MYSQL_DATABASE=$DATABASE" \
        -e "MYSQL_USER=$USER_NAME" \
        -e "MYSQL_PASSWORD=$USER_PASSWORD" \
        \
        -v $DATADIR:/var/lib/mysql \
        \
        $IMAGE;

# --> demora uns 20 segundos para subir

# Testar acesso root no MariaDB:
# docker exec -it --user root mariadb-main mariadb -u root -ptulipasql observium;

# Testar acesso comum para o Observium:
# docker exec -it --user root mariadb-main mariadb -u root -pObsMonit7712 observium;

2.2 – Instalando Observium

Você deve, antes de iniciar o uso das URLs, fazer o registro do nome no seu domínio DNS, exemplo:

  • observium.meu-site.com.br no IP 45.255.128.2
    • Troque “observium.meu-site.com.br” pelo nome desejado;
    • Troque “45.255.128.2” pelo IP público da sua VM/VPS;

Caso não possua IP público nem domínio, pode rodar e acessar pela porta redirecionada.

Bash
# Variaveis
    NAME="observium"
    FQDN="observium.seu-site.com.br"
    LOCAL="$NAME.intranet.br"


    # Imagem em docker em hub.docker.com
    # https://hub.docker.com/u/tmsoftbrasil
    # https://hub.docker.com/r/tmsoftbrasil/observium
    IMAGE="tmsoftbrasil/observium:latest";

    # Timezone - usar do servidor local
    TZ="$(timedatectl show | egrep Timezone= | cut -f2 -d=)";

    # Usuario e senha de administrador
    OBSERVIUM_ADMIN_USER=admin;
    OBSERVIUM_ADMIN_PASS=obs;

    # Acesso ao banco de dados (dados do mariadb)
    OBSERVIUM_DB_HOST="mariadb-main";
    OBSERVIUM_DB_USER="observium";
    OBSERVIUM_DB_PASS="ObsMonit7712";
    OBSERVIUM_DB_NAME="observium";


# Diretorio de dados persistentes:
    DATADIR="/storage/$NAME";
    mkdir -p $DATADIR;
    mkdir -p $DATADIR/logs;


# Remover atual para renovar:
    docker rm -f $NAME 2>/dev/null;


# Baixar imagem atualizada
    docker pull $IMAGE;

# Criar e rodar:
    docker run \
        -d --restart=always \
        --name $NAME -h $LOCAL \
        --tmpfs /run:rw,noexec,nosuid,size=2m \
        --cpus="8.0" --memory=4g --memory-swap=4g \
        \
        --network network_public \
        --mac-address "02:c2:49:25:55:11" \
        \
        -p 3080:80 \
        \
        -e TZ=$TZ \
        \
        -e "OBSERVIUM_ADMIN_USER=$OBSERVIUM_ADMIN_USER" \
        -e "OBSERVIUM_ADMIN_PASS=$OBSERVIUM_ADMIN_PASS" \
        \
        -e "OBSERVIUM_DB_HOST=$OBSERVIUM_DB_HOST" \
        -e "OBSERVIUM_DB_USER=$OBSERVIUM_DB_USER" \
        -e "OBSERVIUM_DB_PASS=$OBSERVIUM_DB_PASS" \
        -e "OBSERVIUM_DB_NAME=$OBSERVIUM_DB_NAME" \
        \
        -v $DATADIR:/data \
        \
        --label "traefik.enable=true" \
        --label "traefik.enable=true" \
        --label "traefik.http.routers.$NAME.rule=Host(\`$FQDN\`)" \
        --label "traefik.http.routers.$NAME.entrypoints=web,websecure" \
        --label "traefik.http.routers.$NAME.tls=true" \
        --label "traefik.http.routers.$NAME.tls.certresolver=letsencrypt" \
        --label "traefik.http.services.$NAME.loadbalancer.server.port=80" \
        \
        $IMAGE;

2.3 – Stack para Docker Compose (para dependêntes do Portainer)

YAML
version: '3.8'

networks:
  network_public:
    driver: bridge
    driver_opts:
      com.docker.network.bridge.name: br-net-public
      com.docker.network.bridge.enable_icc: "true"
      com.docker.network.driver.mtu: "1500"
    ipam:
      config:
        - subnet: 10.249.0.0/16
          gateway: 10.249.255.254
        - subnet: 2001:db8:10:249::/64
          gateway: 2001:db8:10:249::254

services:
  mariadb-main:
    image: mariadb:latest
    container_name: mariadb-main
    hostname: mariadb-main.intranet.br
    restart: always
    networks:
      network_public:
        mac_address: "02:c2:49:25:55:01"
    environment:
      MYSQL_ROOT_PASSWORD: tulipasql
      MYSQL_DATABASE: observium
      MYSQL_USER: observium
      MYSQL_PASSWORD: ObsMonit7712
    volumes:
      - /storage/mariadb-main:/var/lib/mysql

  observium:
    image: tmsoftbrasil/observium:latest
    container_name: observium
    hostname: observium.intranet.br
    restart: always
    depends_on:
      - mariadb-main
    networks:
      network_public:
        mac_address: "02:c2:49:25:55:11"
    ports:
      - "3080:80"
    tmpfs:
      - /run:rw,noexec,nosuid,size=2m
    cpus: "8.0"
    mem_limit: 4g
    memswap_limit: 4g
    environment:
      TZ: America/Sao_Paulo
      OBSERVIUM_ADMIN_USER: admin
      OBSERVIUM_ADMIN_PASS: obs
      OBSERVIUM_DB_HOST: mariadb-main
      OBSERVIUM_DB_USER: observium
      OBSERVIUM_DB_PASS: ObsMonit7712
      OBSERVIUM_DB_NAME: observium
    volumes:
      - /storage/observium:/data
    labels:
      traefik.enable: "true"
      traefik.http.routers.observium.rule: "Host(`observium.seu-site.com.br`)"
      traefik.http.routers.observium.entrypoints: "web,websecure"
      traefik.http.routers.observium.tls: "true"
      traefik.http.routers.observium.tls.certresolver: "letsencrypt"
      traefik.http.services.observium.loadbalancer.server.port: "80"

3 – Usando o Observium

Acesse pela URL se você a configurou (FQDN).

O acesso sempre irá funcionar no IP do servidor na porta HTTP 3080.

Se você não alterou o login e senha no script, o padrão é: admin senha obs

Após entrar, adicione os equipamentos pelo menu Devices – Add Device

O resto é intuitivo! Aguarde entre 1 e 5 minutos para que ele faça o carregamento de todo o inventário.

Boas práticas nos equipamentos a serem monitorados:

  • Nome da community
    • Nunca utilize public como community, nem permita que essa community exista nos equipamentos.
    • Bons nomes para communities:
      • SNMP-Monit (nome simples, não é tão bom mas é melhor que public)
      • SpeedNet-182812 (nome da rede e um número)
      • e76af6b3-c19b-4b13-984a-a5a862ba4dc8 (UUID randomico)
    • Evite usar senhas complexas e cheias de caracteres especiais, isso impede alguns sistemas e atrapalha scripts, obriga você a anotar;
    • Usar SNMPv3 com criptografia em todos os equipamentos que suportarem esse modo;
  • Localização GPS
    • No campo system location das configurações dos equipamentos, prefira colocar a posição numérica de GPS em vez de apenas o nome abstrato do local;
    • Exemplos de posições bem configuradas:
      • -22.90784347591885, -43.12589020717624
      • R. Nair Margem Pereira, 41 – Boa Viagem, Niterói – RJ, 24210-390

Não há muito o que aprender, basta adicionar os equipamentos e assistir!

“O pior cego é aquele que não quer ver”

Terminamos por hoje!

Patrick Brandão, patrickbrandao@gmail.com