Skip to main content

​
Overview

This template provides a production‑ready BIRD routing daemon instance as a Monk runnable. You can:
  • Run it directly to get a managed dynamic routing daemon with sensible defaults
  • Inherit it in your own runnable to seamlessly add BGP, OSPF, RIP, and other routing protocols to your network infrastructure
BIRD (BIRD Internet Routing Daemon) is a fully functional dynamic IP routing daemon for Unix-like systems. It supports IPv4 and IPv6 with all major routing protocols including BGP, OSPF, RIP, and static routes, making it ideal for ISP, datacenter, and enterprise networking.

​
What this template manages

  • BIRD routing daemon container (configurable image tag)
  • Network service with routing protocols
  • Persistent volumes for configuration and state
  • IPv4 and IPv6 routing support
  • Protocol debugging and logging

​
Quick start (run directly)

  1. Load templates
monk load MANIFEST
  1. Run BIRD with defaults
monk run bird/bird
  1. Customize configuration (recommended via inheritance)
Running directly uses the defaults defined in this template’s variables. For production use:
  • Preferred: inherit and customize variables with your own configuration as shown below.
  • Alternative: fork/clone and edit the variables in bird/bird.yaml, then monk load MANIFEST and run.
Once started, BIRD will load configuration and establish routing sessions. Interact with it using birdc commands.

​
Configuration

Key variables you can customize in this template: 
variables:
  bird-image-tag: "latest"            # container image tag
  router-id: "1.1.1.1"                # router ID (usually loopback IP)
  bird-config: "..."                  # custom BIRD configuration
Configuration is persisted under ${monk-volume-path}/bird on the host. State files are stored in ${monk-volume-path}/bird/var:/var/run/bird. Inherit the BIRD runnable in your network infrastructure and customize the routing configuration. Example: 
namespace: mynetwork
router:
  defines: runnable
  inherits: bird/bird
  variables:
    router-id: "10.0.0.1"
  files:
    bird-config:
      container: bird
      path: /etc/bird/bird.conf
      contents: |
        router id 10.0.0.1;
        
        protocol device {
        }
        
        protocol kernel {
          ipv4 {
            import none;
            export all;
          };
        }
        
        protocol bgp peer1 {
          local as 65001;
          neighbor 10.0.0.2 as 65002;
          ipv4 {
            import all;
            export all;
          };
        }
Then run your network infrastructure: 
monk run mynetwork/router

​
Persistence and configuration

  • Config path: ${monk-volume-path}/bird/etc:/etc/bird
  • State path: ${monk-volume-path}/bird/var:/var/run/bird
  • You can mount custom BIRD configuration files into the config path to tune routing behavior.

​
Features

  • Multi-Protocol: BGP-4, OSPFv2, OSPFv3, RIPv2, RIPng
  • IPv6 Support: Full IPv4 and IPv6 routing
  • BGP Features: Route reflection, confederations, graceful restart
  • Filtering: Powerful route filtering language
  • Multiple RIBs: Support for multiple routing tables
  • Fast Convergence: Efficient route updates
  • Scripting: Extensive configuration language

​
BGP Configuration

Example BGP peering: 
protocol bgp peer_upstream {
  description "Upstream ISP";
  local as 65001;
  neighbor 203.0.113.1 as 65000;
  
  ipv4 {
    import filter {
      # Accept default route
      if net = 0.0.0.0/0 then accept;
      reject;
    };
    export filter {
      # Export our networks
      if net ~ [ 198.51.100.0/24 ] then accept;
      reject;
    };
  };
}

​
OSPF Configuration

Example OSPF: 
protocol ospf v2 ospf_internal {
  ipv4 {
    import all;
    export all;
  };
  
  area 0.0.0.0 {
    interface "eth0" {
      hello 10;
      dead 40;
      type broadcast;
    };
  };
}

​
Static Routes

protocol static {
  ipv4;
  
  route 0.0.0.0/0 via 10.0.0.1;
  route 192.168.1.0/24 via 10.0.1.1;
}

​
BIRD Control

Interact with BIRD using birdc: 
# Check BIRD status
birdc show status

# Show routes
birdc show route

# Show protocols
birdc show protocols

# Show BGP details
birdc show protocol all bgp_peer1

# Reload configuration
birdc configure

​
Use cases

BIRD excels at:
  • ISP and datacenter routing
  • BGP peering and internet exchange points (IXP)
  • Enterprise OSPF networks
  • Route servers
  • Anycast routing
  • Software-defined networking (SDN)
  • Combine with monitoring tools for network observability
  • See other networking templates in this repository for complementary services

​
Troubleshooting

  • If routing protocols are not establishing sessions, verify neighbor IPs are reachable and firewall rules allow routing traffic (TCP 179 for BGP).
  • Ensure configuration syntax is correct by testing with birdc configure after changes.
  • Check logs:
monk logs -l 500 -f bird/bird
  • Verify BIRD status:
birdc show status
  • View protocol states:
birdc show protocols
  • Debug specific protocol by adding debug all; to the protocol configuration in bird.conf
  • For BGP session issues:
    • Verify neighbor IP is reachable
    • Check AS numbers match configuration
    • Verify firewall allows TCP 179
  • For OSPF issues, check interface configurations and area settings
  • Use birdc show route to inspect routing table entries