Running monitoring software on your core router is unconventional, but RouterOS 7 containers make it viable. You can deploy YAD inside a RouterOS container, monitor your entire network from your core router, and keep everything in one physical location. This guide walks through it step-by-step.

Why Run Monitoring in RouterOS?

Traditional Approach

ISP Network (routers, switches, ONTs)
    ↓
Separate Monitoring Server (Raspberry Pi, VM)
    ↓ (SNMP over network)
Centralized Dashboard

Pros: Clean separation, single-purpose server Cons: Extra hardware, extra power consumption, extra network path to manage

RouterOS Container Approach

ISP Network (routers, switches, ONTs)
    ↓ (SNMP via localhost + local network)
Core Router (RB4011)
  ├─ RouterOS OS
  └─ YAD Container (monitoring)

Pros:

Cons:

Prerequisites

Check your device:

/system print
# output: RouterOS 7.8.1, board RB4011, RAM 2048 MB

/disk print
# output: ether.img (flash), capacity 4096 MB, used 1500 MB, free 2596 MB

Step 1: Enable Container Mode on RouterOS

/system package enable container
/interface bridge add name=docker
/ip address add address=172.17.0.1/24 interface=docker

Reboot:

/system reboot

Verify container is running:

/container print
# output: (should show new container interface)

/interface print
# output: docker (interface now visible)

Step 2: Prepare YAD Container Image

You have two options:

Option A: Use Pre-Built Image (Easier)

# On a Linux machine, download and prepare YAD container:
docker pull yetanotherdude/yad:latest
docker save yetanotherdude/yad:latest -o yad-container.tar

# Transfer to RouterOS via SCP:
scp yad-container.tar admin@ROUTER_IP:/

Option B: Build Minimal Image

If pre-built isn’t available, build a minimal Alpine Linux image:

# Dockerfile
FROM alpine:3.18
RUN apk add --no-cache ca-certificates libc6-compat
COPY yad-linux-amd64 /usr/local/bin/yad
RUN chmod +x /usr/local/bin/yad
EXPOSE 8080
CMD ["yad"]

Build:

docker build -t yad-container:latest .
docker save yad-container:latest -o yad-container.tar

Step 3: Import Container Image to RouterOS

SSH into your router:

ssh admin@ROUTER_IP

Import the tar file:

/container import file=yad-container.tar

Verify import:

/container print
# output: NAME=yad, IMAGE=yetanotherdude/yad:latest

Step 4: Create Container Instance

Create a running container with volume mount for persistent data:

/container add name=yad image=yad-container:latest interface=docker root-dir=/yad-data

Create storage directory:

/file print detail
# Find your flash disk (usually ether.img)

# Create yad data directory (if not exists):
:if ([/file find name=yad-data] = "") do={ /file make-dir name=yad-data }

Step 5: Configure Container Networking

Expose port 8080 (YAD web UI) on the router:

/container set name=yad mounts=yad-data logging=yes
/container interface add container=yad interface=docker address=172.17.0.2/24 gateway=172.17.0.1

Port forwarding (so you can access from outside the router):

/ip firewall nat add chain=dstnat protocol=tcp dst-port=8080 in-interface=ether1 action=dst-nat to-addresses=172.17.0.2 to-ports=8080
/ip firewall filter add chain=forward protocol=tcp dst-port=8080 action=accept in-interface=ether1

This exposes YAD on http://ROUTER_IP:8080.

Step 6: Start the Container

/container start name=yad

Monitor startup:

/container print
# Look at status column; should transition: creating → running

# Check logs:
/container print detail name=yad
# Shows startup messages

Wait 10–20 seconds for YAD to start, then test:

# From your workstation:
curl http://ROUTER_IP:8080
# Should return HTML (YAD dashboard)

Step 7: Configure YAD (Initial Setup)

Open browser: http://ROUTER_IP:8080

  1. Create admin user — Set password (YAD default is no password)
  2. Add devices:
  3. Configure SNMP — For each device, set SNMP v2c or v3 credentials
  4. Set polling interval — 30 seconds default (good for <100 devices)

Step 8: Enable SNMP on Monitored Devices

On each device you want to monitor:

/snmp set enabled=yes community=ISP_MONITOR
/snmp user add name=monitoring auth-protocol=MD5 auth-password="PASS" privacy-protocol=AES privacy-password="PASS"

Test SNMP from router:

/snmp test address=192.168.1.1 community=ISP_MONITOR oid=1.3.6.1.2.1.1.5.0
# output: .1.3.6.1.2.1.1.5.0 = STRING: "regional-hub-1"

Step 9: Configure Alerts (Optional)

YAD can alert via webhooks. Configure Slack integration:

  1. Create Slack webhook: https://api.slack.com/messaging/webhooks
  2. In YAD UI: Settings → Alerts → Webhooks
  3. Paste webhook URL, test

Accessing YAD Dashboard

Local Network (LAN)

From any computer on your LAN:

http://192.168.1.1:8080

(Assuming your router’s LAN IP is 192.168.1.1)

Remote Access (Optional, Requires VPN)

Don’t expose port 8080 to the internet without authentication. Instead:

  1. Use WireGuard/OpenVPN tunnel to your router
  2. Access YAD via private IP while tunneled

Or use reverse proxy on router with basic auth:

/ip proxy set enabled=yes src-address=0.0.0.0 port=8080
# ... configure proxy rules ...

(More complex; better to use VPN)

Monitoring Resource Usage

The container shares CPU and RAM with router. Check impact:

/system resource print
# Output example:
# uptime: 18w1d15h45m2s
# cpu-frequency: 800 MHz
# cpu-load: 12%  <-- includes container CPU
# free-memory: 200 MB  <-- includes container RAM
# free-hdd-space: 1.5 GB

Expected resource usage (YAD with 50 devices):

Troubleshooting

Container Won’t Start

/container print detail name=yad
# Shows "ERROR: ..." in status

Solution: Check image exists:

/container images print
# List all available images

If missing, re-import:

/container import file=yad-container.tar

Can’t Connect to Dashboard

Check port is open:

/ip firewall nat print
# Verify dst-port=8080 rule exists

/ip firewall filter print
# Verify forward chain allows port 8080

Test from router console:

/tool fetch url=http://172.17.0.2:8080
# Should return HTTP 200

SNMP Queries Timeout

Verify router can reach monitored device:

/ping 192.168.1.1
# output: 4 packets transmitted, 4 received, 0% packet loss, min=2ms, avg=3ms, max=4ms

Verify firewall allows SNMP (UDP 161):

/ip firewall filter add chain=input protocol=udp dst-port=161 action=accept
/ip firewall filter add chain=forward protocol=udp dst-port=161 action=accept

Backing Up YAD Data

Data lives in /yad-data directory. Back it up to avoid data loss:

/file print
# List all files/dirs

# Export data dir to USB or external storage:
/file export-dir name=yad-data

Or SSH it out:

# From your workstation:
scp -r admin@ROUTER_IP:/yad-data/ ./backup-yad/

Scaling Beyond the Router

If you grow beyond 100 devices, the router can’t handle both routing and monitoring. Migrate YAD to dedicated hardware:

  1. Export data from router container
  2. Deploy YAD on Raspberry Pi or VM
  3. Import data (if YAD supports import) or re-add devices
  4. Update monitoring source in your documentation

The RouterOS container approach is great for small networks (< 100 devices), but enterprise infrastructure needs dedicated monitoring.

Conclusion

Running YAD in a RouterOS container is viable for ISPs with <100 devices. You get centralized monitoring, self-contained deployment, and zero extra hardware cost. For larger networks, migrate to dedicated hardware (Raspberry Pi, VM) to separate monitoring from routing.

The key takeaway: RouterOS containers enable new deployment patterns. You’re no longer limited to “monitoring software runs on a PC.” Now it runs anywhere: Pi, container, router, cloud—all the same binary.

Deploy YAD in RouterOS → yetanotherdude.io
Container-ready, runs on RB4011/RB5009, local SNMP polling, zero extra hardware.