Software-Defined Networking on Alpine Linux 🌐

Software-Defined Networking (SDN) is like giving your network a programmable brain! 🧠 Instead of configuring each network device individually, SDN lets you control your entire network from a central point using software. Let’s build a complete SDN environment on Alpine Linux! 🚀

What is Software-Defined Networking? 🤔

SDN separates networking into:

• Control Plane - The brain that makes decisions
• Data Plane - The muscles that forward packets
• Application Layer - Apps that use the network
• Management - APIs to control everything
• Programmability - Change network behavior with code

Think of it as turning your network into a programmable computer! 💻

Installing SDN Components 📦

Set up the core SDN infrastructure:

# Update package list
sudo apk update

# Install Open vSwitch
sudo apk add openvswitch openvswitch-ovn

# Install Python for SDN controllers
sudo apk add python3 py3-pip python3-dev
sudo apk add gcc musl-dev linux-headers

# Install development tools
sudo apk add git make cmake
sudo apk add iproute2 bridge-utils

# Install monitoring tools
sudo apk add tcpdump wireshark-cli
sudo apk add iperf3 netcat-openbsd

Setting Up Open vSwitch 🔄

Create virtual switches and networks:

# Start Open vSwitch
sudo rc-service ovsdb-server start
sudo rc-service ovs-vswitchd start
sudo rc-update add ovsdb-server
sudo rc-update add ovs-vswitchd

# Create your first virtual switch
sudo ovs-vsctl add-br br0

# Show switch configuration
sudo ovs-vsctl show

# Create SDN topology script
cat > setup_sdn_topology.sh << 'EOF'
#!/bin/sh
# SDN Topology Setup

echo "Creating SDN topology..."

# Create virtual switches
ovs-vsctl add-br br-core     # Core switch
ovs-vsctl add-br br-access1  # Access switch 1
ovs-vsctl add-br br-access2  # Access switch 2

# Create virtual patch cables between switches
ovs-vsctl add-port br-core patch-core-acc1 \
    -- set interface patch-core-acc1 type=patch options:peer=patch-acc1-core
ovs-vsctl add-port br-access1 patch-acc1-core \
    -- set interface patch-acc1-core type=patch options:peer=patch-core-acc1

ovs-vsctl add-port br-core patch-core-acc2 \
    -- set interface patch-core-acc2 type=patch options:peer=patch-acc2-core
ovs-vsctl add-port br-access2 patch-acc2-core \
    -- set interface patch-acc2-core type=patch options:peer=patch-core-acc2

# Set OpenFlow controller
ovs-vsctl set-controller br-core tcp:127.0.0.1:6653
ovs-vsctl set-controller br-access1 tcp:127.0.0.1:6653
ovs-vsctl set-controller br-access2 tcp:127.0.0.1:6653

# Enable OpenFlow 1.3
ovs-vsctl set bridge br-core protocols=OpenFlow13
ovs-vsctl set bridge br-access1 protocols=OpenFlow13
ovs-vsctl set bridge br-access2 protocols=OpenFlow13

echo "SDN topology created!"
ovs-vsctl show
EOF

chmod +x setup_sdn_topology.sh
sudo ./setup_sdn_topology.sh

Installing Ryu SDN Controller 🎮

Set up a Python-based SDN controller:

# Create virtual environment
python3 -m venv sdn-env
source sdn-env/bin/activate

# Install Ryu controller
pip install ryu networkx

# Create basic SDN controller
mkdir -p ~/sdn-controller
cd ~/sdn-controller

cat > simple_switch.py << 'EOF'
#!/usr/bin/env python3
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_3
from ryu.lib.packet import packet, ethernet, ether_types

class SimpleSwitch(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

    def __init__(self, *args, **kwargs):
        super(SimpleSwitch, self).__init__(*args, **kwargs)
        self.mac_to_port = {}

    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
    def switch_features_handler(self, ev):
        """Handle switch connection"""
        datapath = ev.msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        # Install default flow to send unknown packets to controller
        match = parser.OFPMatch()
        actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
                                          ofproto.OFPCML_NO_BUFFER)]
        self.add_flow(datapath, 0, match, actions)
        
        self.logger.info("Switch %s connected", datapath.id)

    def add_flow(self, datapath, priority, match, actions, buffer_id=None):
        """Add a flow to the switch"""
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
                                              actions)]
        if buffer_id:
            mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id,
                                    priority=priority, match=match,
                                    instructions=inst)
        else:
            mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
                                    match=match, instructions=inst)
        datapath.send_msg(mod)

    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        """Handle packets sent to controller"""
        msg = ev.msg
        datapath = msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser
        in_port = msg.match['in_port']

        pkt = packet.Packet(msg.data)
        eth = pkt.get_protocols(ethernet.ethernet)[0]

        if eth.ethertype == ether_types.ETH_TYPE_LLDP:
            # Ignore LLDP packets
            return

        dst = eth.dst
        src = eth.src
        dpid = datapath.id

        self.mac_to_port.setdefault(dpid, {})

        # Learn MAC address
        self.mac_to_port[dpid][src] = in_port
        self.logger.info("Learned: dpid=%s src=%s port=%s", dpid, src, in_port)

        # Lookup MAC address
        if dst in self.mac_to_port[dpid]:
            out_port = self.mac_to_port[dpid][dst]
        else:
            out_port = ofproto.OFPP_FLOOD

        actions = [parser.OFPActionOutput(out_port)]

        # Install flow to avoid packet_in next time
        if out_port != ofproto.OFPP_FLOOD:
            match = parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src)
            self.add_flow(datapath, 1, match, actions, msg.buffer_id)
            self.logger.info("Flow added: dpid=%s src=%s dst=%s out_port=%s",
                           dpid, src, dst, out_port)

        # Send packet out
        data = None
        if msg.buffer_id == ofproto.OFP_NO_BUFFER:
            data = msg.data

        out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
                                  in_port=in_port, actions=actions, data=data)
        datapath.send_msg(out)
EOF

# Run the controller
ryu-manager simple_switch.py

Advanced SDN Applications 🛠️

Build sophisticated network applications:

# Load balancer application
cat > load_balancer.py << 'EOF'
#!/usr/bin/env python3
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_3
from ryu.lib.packet import packet, ethernet, ipv4, tcp, arp
import random

class LoadBalancer(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

    def __init__(self, *args, **kwargs):
        super(LoadBalancer, self).__init__(*args, **kwargs)
        
        # Virtual IP for load balancer
        self.virtual_ip = "10.0.0.100"
        self.virtual_mac = "00:00:00:00:00:ff"
        
        # Backend servers
        self.servers = [
            {"ip": "10.0.0.1", "mac": "00:00:00:00:00:01", "port": 1},
            {"ip": "10.0.0.2", "mac": "00:00:00:00:00:02", "port": 2},
            {"ip": "10.0.0.3", "mac": "00:00:00:00:00:03", "port": 3}
        ]
        
        # Connection tracking
        self.connections = {}

    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
    def switch_features_handler(self, ev):
        datapath = ev.msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        # Default flow
        match = parser.OFPMatch()
        actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
                                          ofproto.OFPCML_NO_BUFFER)]
        self.add_flow(datapath, 0, match, actions)

    def add_flow(self, datapath, priority, match, actions, idle_timeout=0):
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
                                              actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
                                idle_timeout=idle_timeout,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

    def select_server(self, src_ip):
        """Select server using round-robin or hash-based selection"""
        # Simple hash-based selection for session persistence
        hash_val = hash(src_ip)
        return self.servers[hash_val % len(self.servers)]

    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        msg = ev.msg
        datapath = msg.datapath
        parser = datapath.ofproto_parser
        in_port = msg.match['in_port']
        
        pkt = packet.Packet(msg.data)
        eth = pkt.get_protocol(ethernet.ethernet)
        
        # Handle ARP requests for virtual IP
        arp_pkt = pkt.get_protocol(arp.arp)
        if arp_pkt and arp_pkt.dst_ip == self.virtual_ip:
            self.handle_arp(datapath, in_port, eth, arp_pkt)
            return
        
        # Handle IPv4 traffic
        ipv4_pkt = pkt.get_protocol(ipv4.ipv4)
        if ipv4_pkt:
            tcp_pkt = pkt.get_protocol(tcp.tcp)
            
            if ipv4_pkt.dst == self.virtual_ip and tcp_pkt:
                # Incoming request to virtual IP
                self.handle_incoming(datapath, in_port, eth, ipv4_pkt, tcp_pkt)
            elif ipv4_pkt.src in [s["ip"] for s in self.servers]:
                # Response from server
                self.handle_response(datapath, in_port, eth, ipv4_pkt, tcp_pkt)

    def handle_arp(self, datapath, in_port, eth, arp_pkt):
        """Respond to ARP requests for virtual IP"""
        parser = datapath.ofproto_parser
        
        # Create ARP reply
        arp_reply = packet.Packet()
        arp_reply.add_protocol(ethernet.ethernet(
            ethertype=eth.ethertype,
            dst=eth.src,
            src=self.virtual_mac
        ))
        arp_reply.add_protocol(arp.arp(
            opcode=arp.ARP_REPLY,
            src_mac=self.virtual_mac,
            src_ip=self.virtual_ip,
            dst_mac=arp_pkt.src_mac,
            dst_ip=arp_pkt.src_ip
        ))
        
        arp_reply.serialize()
        
        actions = [parser.OFPActionOutput(in_port)]
        out = parser.OFPPacketOut(
            datapath=datapath,
            buffer_id=datapath.ofproto.OFP_NO_BUFFER,
            in_port=datapath.ofproto.OFPP_CONTROLLER,
            actions=actions,
            data=arp_reply.data
        )
        datapath.send_msg(out)

    def handle_incoming(self, datapath, in_port, eth, ipv4_pkt, tcp_pkt):
        """Handle incoming requests to load balancer"""
        parser = datapath.ofproto_parser
        
        # Select backend server
        server = self.select_server(ipv4_pkt.src)
        
        # Track connection
        conn_id = (ipv4_pkt.src, tcp_pkt.src_port)
        self.connections[conn_id] = server
        
        # Install flows for this connection
        # Client -> Server
        match = parser.OFPMatch(
            in_port=in_port,
            eth_type=0x0800,
            ipv4_src=ipv4_pkt.src,
            ipv4_dst=self.virtual_ip,
            ip_proto=6,
            tcp_src=tcp_pkt.src_port
        )
        actions = [
            parser.OFPActionSetField(eth_dst=server["mac"]),
            parser.OFPActionSetField(ipv4_dst=server["ip"]),
            parser.OFPActionOutput(server["port"])
        ]
        self.add_flow(datapath, 100, match, actions, idle_timeout=300)
        
        # Server -> Client
        match = parser.OFPMatch(
            in_port=server["port"],
            eth_type=0x0800,
            ipv4_src=server["ip"],
            ipv4_dst=ipv4_pkt.src,
            ip_proto=6,
            tcp_dst=tcp_pkt.src_port
        )
        actions = [
            parser.OFPActionSetField(eth_src=self.virtual_mac),
            parser.OFPActionSetField(ipv4_src=self.virtual_ip),
            parser.OFPActionOutput(in_port)
        ]
        self.add_flow(datapath, 100, match, actions, idle_timeout=300)
        
        self.logger.info("Load balanced connection from %s:%s to server %s",
                        ipv4_pkt.src, tcp_pkt.src_port, server["ip"])
EOF

# Firewall application
cat > sdn_firewall.py << 'EOF'
#!/usr/bin/env python3
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_3
from ryu.lib.packet import packet, ethernet, ipv4, tcp, udp, icmp
import json

class SDNFirewall(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

    def __init__(self, *args, **kwargs):
        super(SDNFirewall, self).__init__(*args, **kwargs)
        
        # Load firewall rules
        self.rules = self.load_rules()
        self.blocked_hosts = set()

    def load_rules(self):
        """Load firewall rules from file"""
        try:
            with open('firewall_rules.json', 'r') as f:
                return json.load(f)
        except:
            # Default rules
            return {
                "allow": [
                    {"src_ip": "10.0.0.0/24", "dst_port": 80, "protocol": "tcp"},
                    {"src_ip": "10.0.0.0/24", "dst_port": 443, "protocol": "tcp"},
                    {"protocol": "icmp"}
                ],
                "deny": [
                    {"src_ip": "192.168.1.0/24"},
                    {"dst_port": 22, "protocol": "tcp"}
                ]
            }

    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
    def switch_features_handler(self, ev):
        datapath = ev.msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        # Install default deny rule (low priority)
        match = parser.OFPMatch()
        actions = []  # Empty actions = drop
        self.add_flow(datapath, 1, match, actions)
        
        # Send all packets to controller for inspection
        actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
                                          ofproto.OFPCML_NO_BUFFER)]
        self.add_flow(datapath, 2, match, actions)

    def add_flow(self, datapath, priority, match, actions):
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
                                              actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
                                match=match, instructions=inst)
        datapath.send_msg(mod)

    def check_rules(self, pkt_info):
        """Check if packet matches firewall rules"""
        # Check deny rules first
        for rule in self.rules.get("deny", []):
            if self.match_rule(pkt_info, rule):
                return False
        
        # Check allow rules
        for rule in self.rules.get("allow", []):
            if self.match_rule(pkt_info, rule):
                return True
        
        # Default deny
        return False

    def match_rule(self, pkt_info, rule):
        """Check if packet matches a specific rule"""
        # Match source IP
        if "src_ip" in rule:
            if not self.ip_in_network(pkt_info.get("src_ip"), rule["src_ip"]):
                return False
        
        # Match destination IP
        if "dst_ip" in rule:
            if not self.ip_in_network(pkt_info.get("dst_ip"), rule["dst_ip"]):
                return False
        
        # Match protocol
        if "protocol" in rule:
            if pkt_info.get("protocol") != rule["protocol"]:
                return False
        
        # Match ports
        if "src_port" in rule and pkt_info.get("src_port") != rule["src_port"]:
            return False
        if "dst_port" in rule and pkt_info.get("dst_port") != rule["dst_port"]:
            return False
        
        return True

    def ip_in_network(self, ip, network):
        """Check if IP is in network (simplified)"""
        # In production, use proper IP network library
        return ip.startswith(network.split('/')[0].rsplit('.', 1)[0])

    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        msg = ev.msg
        datapath = msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser
        in_port = msg.match['in_port']
        
        pkt = packet.Packet(msg.data)
        eth = pkt.get_protocol(ethernet.ethernet)
        
        # Extract packet info
        pkt_info = {"in_port": in_port}
        
        # Check IPv4
        ipv4_pkt = pkt.get_protocol(ipv4.ipv4)
        if ipv4_pkt:
            pkt_info["src_ip"] = ipv4_pkt.src
            pkt_info["dst_ip"] = ipv4_pkt.dst
            
            # Check TCP
            tcp_pkt = pkt.get_protocol(tcp.tcp)
            if tcp_pkt:
                pkt_info["protocol"] = "tcp"
                pkt_info["src_port"] = tcp_pkt.src_port
                pkt_info["dst_port"] = tcp_pkt.dst_port
            
            # Check UDP
            udp_pkt = pkt.get_protocol(udp.udp)
            if udp_pkt:
                pkt_info["protocol"] = "udp"
                pkt_info["src_port"] = udp_pkt.src_port
                pkt_info["dst_port"] = udp_pkt.dst_port
            
            # Check ICMP
            if pkt.get_protocol(icmp.icmp):
                pkt_info["protocol"] = "icmp"
        
        # Apply firewall rules
        allowed = self.check_rules(pkt_info)
        
        if allowed:
            # Allow packet - install flow and forward
            self.logger.info("ALLOW: %s", pkt_info)
            
            # Forward to all ports (simplified)
            actions = [parser.OFPActionOutput(ofproto.OFPP_FLOOD)]
            
            # Install flow for this type of traffic
            if ipv4_pkt and tcp_pkt:
                match = parser.OFPMatch(
                    eth_type=0x0800,
                    ipv4_src=ipv4_pkt.src,
                    ipv4_dst=ipv4_pkt.dst,
                    ip_proto=6,
                    tcp_dst=tcp_pkt.dst_port
                )
                self.add_flow(datapath, 100, match, actions)
            
            # Send packet out
            data = None
            if msg.buffer_id == ofproto.OFP_NO_BUFFER:
                data = msg.data
                
            out = parser.OFPPacketOut(
                datapath=datapath,
                buffer_id=msg.buffer_id,
                in_port=in_port,
                actions=actions,
                data=data
            )
            datapath.send_msg(out)
        else:
            # Block packet
            self.logger.warning("DENY: %s", pkt_info)
            # No action = drop packet
EOF

Network Virtualization 🌍

Create virtual networks with namespaces:

# Network virtualization script
cat > create_virtual_networks.sh << 'EOF'
#!/bin/sh
# Create Virtual Networks with SDN

# Create network namespaces (virtual hosts)
ip netns add host1
ip netns add host2
ip netns add host3
ip netns add host4

# Create virtual ethernet pairs
ip link add veth1 type veth peer name veth1-br
ip link add veth2 type veth peer name veth2-br
ip link add veth3 type veth peer name veth3-br
ip link add veth4 type veth peer name veth4-br

# Move veth interfaces to namespaces
ip link set veth1 netns host1
ip link set veth2 netns host2
ip link set veth3 netns host3
ip link set veth4 netns host4

# Connect to OVS bridges
ovs-vsctl add-port br-access1 veth1-br
ovs-vsctl add-port br-access1 veth2-br
ovs-vsctl add-port br-access2 veth3-br
ovs-vsctl add-port br-access2 veth4-br

# Configure IP addresses
ip netns exec host1 ip addr add 10.0.1.1/24 dev veth1
ip netns exec host2 ip addr add 10.0.1.2/24 dev veth2
ip netns exec host3 ip addr add 10.0.2.1/24 dev veth3
ip netns exec host4 ip addr add 10.0.2.2/24 dev veth4

# Bring up interfaces
ip link set veth1-br up
ip link set veth2-br up
ip link set veth3-br up
ip link set veth4-br up

ip netns exec host1 ip link set veth1 up
ip netns exec host2 ip link set veth2 up
ip netns exec host3 ip link set veth3 up
ip netns exec host4 ip link set veth4 up

ip netns exec host1 ip link set lo up
ip netns exec host2 ip link set lo up
ip netns exec host3 ip link set lo up
ip netns exec host4 ip link set lo up

echo "Virtual networks created!"
echo "Test connectivity with: ip netns exec host1 ping 10.0.1.2"
EOF

chmod +x create_virtual_networks.sh
sudo ./create_virtual_networks.sh

SDN Monitoring and Analytics 📊

Monitor SDN performance:

# Flow statistics collector
cat > flow_monitor.py << 'EOF'
#!/usr/bin/env python3
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER, DEAD_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.lib import hub
from ryu.ofproto import ofproto_v1_3
import json
import datetime

class FlowMonitor(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

    def __init__(self, *args, **kwargs):
        super(FlowMonitor, self).__init__(*args, **kwargs)
        self.datapaths = {}
        self.monitor_thread = hub.spawn(self._monitor)
        self.flow_stats = {}
        self.port_stats = {}

    @set_ev_cls(ofp_event.EventOFPStateChange, [MAIN_DISPATCHER, DEAD_DISPATCHER])
    def state_change_handler(self, ev):
        datapath = ev.datapath
        if ev.state == MAIN_DISPATCHER:
            if datapath.id not in self.datapaths:
                self.logger.info('Datapath registered: %016x', datapath.id)
                self.datapaths[datapath.id] = datapath
        elif ev.state == DEAD_DISPATCHER:
            if datapath.id in self.datapaths:
                self.logger.info('Datapath unregistered: %016x', datapath.id)
                del self.datapaths[datapath.id]

    def _monitor(self):
        while True:
            for dp in self.datapaths.values():
                self._request_stats(dp)
            hub.sleep(10)  # Request stats every 10 seconds

    def _request_stats(self, datapath):
        self.logger.debug('Send stats request: %016x', datapath.id)
        parser = datapath.ofproto_parser

        # Request flow stats
        req = parser.OFPFlowStatsRequest(datapath)
        datapath.send_msg(req)

        # Request port stats
        req = parser.OFPPortStatsRequest(datapath, 0)
        datapath.send_msg(req)

    @set_ev_cls(ofp_event.EventOFPFlowStatsReply, MAIN_DISPATCHER)
    def flow_stats_reply_handler(self, ev):
        body = ev.msg.body
        dpid = ev.msg.datapath.id
        
        self.flow_stats[dpid] = []
        
        for stat in sorted([flow for flow in body if flow.priority > 0],
                          key=lambda flow: (flow.match.get('in_port', 0),
                                          flow.match.get('eth_dst', 0))):
            self.flow_stats[dpid].append({
                'table_id': stat.table_id,
                'duration': stat.duration_sec,
                'priority': stat.priority,
                'packets': stat.packet_count,
                'bytes': stat.byte_count,
                'match': dict(stat.match),
                'actions': [str(a) for a in stat.instructions[0].actions]
            })
        
        # Save stats to file
        self.save_stats()

    @set_ev_cls(ofp_event.EventOFPPortStatsReply, MAIN_DISPATCHER)
    def port_stats_reply_handler(self, ev):
        body = ev.msg.body
        dpid = ev.msg.datapath.id
        
        self.port_stats[dpid] = []
        
        for stat in sorted(body, key=lambda x: x.port_no):
            self.port_stats[dpid].append({
                'port': stat.port_no,
                'rx_packets': stat.rx_packets,
                'tx_packets': stat.tx_packets,
                'rx_bytes': stat.rx_bytes,
                'tx_bytes': stat.tx_bytes,
                'rx_dropped': stat.rx_dropped,
                'tx_dropped': stat.tx_dropped,
                'rx_errors': stat.rx_errors,
                'tx_errors': stat.tx_errors
            })

    def save_stats(self):
        """Save statistics to JSON file"""
        stats = {
            'timestamp': datetime.datetime.now().isoformat(),
            'flow_stats': self.flow_stats,
            'port_stats': self.port_stats
        }
        
        with open('sdn_stats.json', 'w') as f:
            json.dump(stats, f, indent=2)
        
        # Also create human-readable report
        self.generate_report()

    def generate_report(self):
        """Generate human-readable statistics report"""
        with open('sdn_report.txt', 'w') as f:
            f.write("SDN Network Statistics Report\n")
            f.write(f"Generated: {datetime.datetime.now()}\n")
            f.write("=" * 50 + "\n\n")
            
            for dpid, flows in self.flow_stats.items():
                f.write(f"Switch DPID: {dpid:016x}\n")
                f.write("-" * 30 + "\n")
                
                total_packets = sum(f['packets'] for f in flows)
                total_bytes = sum(f['bytes'] for f in flows)
                
                f.write(f"Total Flows: {len(flows)}\n")
                f.write(f"Total Packets: {total_packets:,}\n")
                f.write(f"Total Bytes: {total_bytes:,}\n\n")
                
                # Top flows by packets
                f.write("Top 5 Flows by Packets:\n")
                for flow in sorted(flows, key=lambda x: x['packets'], reverse=True)[:5]:
                    f.write(f"  Match: {flow['match']}\n")
                    f.write(f"  Packets: {flow['packets']:,}, Bytes: {flow['bytes']:,}\n")
                    f.write(f"  Actions: {flow['actions']}\n\n")
                
                # Port statistics
                if dpid in self.port_stats:
                    f.write("\nPort Statistics:\n")
                    for port in self.port_stats[dpid]:
                        if port['port'] < 1000:  # Skip special ports
                            f.write(f"  Port {port['port']}:\n")
                            f.write(f"    RX: {port['rx_packets']:,} packets, {port['rx_bytes']:,} bytes\n")
                            f.write(f"    TX: {port['tx_packets']:,} packets, {port['tx_bytes']:,} bytes\n")
                            f.write(f"    Errors: RX={port['rx_errors']}, TX={port['tx_errors']}\n")
                
                f.write("\n")
EOF

SDN Testing Tools 🧪

Test your SDN setup:

# SDN test suite
cat > test_sdn.sh << 'EOF'
#!/bin/sh
# SDN Testing Script

echo "=== SDN Network Tests ==="

# Test 1: Connectivity between hosts
echo -e "\n1. Testing basic connectivity..."
ip netns exec host1 ping -c 3 10.0.1.2
ip netns exec host3 ping -c 3 10.0.2.2

# Test 2: Flow installation
echo -e "\n2. Checking OpenFlow flows..."
ovs-ofctl dump-flows br-core
ovs-ofctl dump-flows br-access1

# Test 3: Controller connection
echo -e "\n3. Checking controller connections..."
ovs-vsctl show | grep -A 1 "Controller"

# Test 4: Port statistics
echo -e "\n4. Port statistics..."
ovs-ofctl dump-ports br-core

# Test 5: Bandwidth test
echo -e "\n5. Bandwidth test between hosts..."
ip netns exec host1 iperf3 -s -D
sleep 2
ip netns exec host2 iperf3 -c 10.0.1.1 -t 10

# Test 6: Load balancer test
echo -e "\n6. Testing load balancer..."
for i in $(seq 1 10); do
    ip netns exec host1 curl -s http://10.0.0.100/ &
done
wait

# Test 7: Firewall test
echo -e "\n7. Testing firewall rules..."
# Should be allowed
ip netns exec host1 ping -c 2 10.0.1.2
# Should be blocked (if configured)
ip netns exec host1 nc -zv 10.0.1.2 22

echo -e "\nSDN tests completed!"
EOF

chmod +x test_sdn.sh

SDN Management Dashboard 🖥️

Create a web interface for SDN management:

# Simple SDN dashboard
cat > sdn_dashboard.py << 'EOF'
#!/usr/bin/env python3
from flask import Flask, render_template, jsonify
import requests
import json

app = Flask(__name__)

# Ryu REST API endpoint
RYU_API = "http://localhost:8080"

@app.route('/')
def index():
    return '''
    <!DOCTYPE html>
    <html>
    <head>
        <title>SDN Dashboard</title>
        <style>
            body { font-family: Arial; margin: 20px; }
            .container { max-width: 1200px; margin: 0 auto; }
            .stats { display: grid; grid-template-columns: repeat(3, 1fr); gap: 20px; }
            .stat-box { background: #f0f0f0; padding: 20px; border-radius: 8px; }
            .switch { background: #e0e0e0; margin: 10px 0; padding: 15px; border-radius: 5px; }
            table { width: 100%; border-collapse: collapse; margin-top: 10px; }
            th, td { padding: 8px; text-align: left; border-bottom: 1px solid #ddd; }
            .status-active { color: green; }
            .status-inactive { color: red; }
        </style>
        <script>
            async function updateStats() {
                const response = await fetch('/api/stats');
                const data = await response.json();
                document.getElementById('stats').innerHTML = JSON.stringify(data, null, 2);
            }
            
            setInterval(updateStats, 5000);
            updateStats();
        </script>
    </head>
    <body>
        <div class="container">
            <h1>SDN Network Dashboard</h1>
            
            <div class="stats">
                <div class="stat-box">
                    <h3>Switches</h3>
                    <div id="switches">Loading...</div>
                </div>
                
                <div class="stat-box">
                    <h3>Flows</h3>
                    <div id="flows">Loading...</div>
                </div>
                
                <div class="stat-box">
                    <h3>Traffic</h3>
                    <div id="traffic">Loading...</div>
                </div>
            </div>
            
            <h2>Network Statistics</h2>
            <pre id="stats">Loading...</pre>
        </div>
    </body>
    </html>
    '''

@app.route('/api/stats')
def get_stats():
    try:
        # Get switches
        switches = requests.get(f"{RYU_API}/stats/switches").json()
        
        stats = {
            'switches': switches,
            'flows': {},
            'ports': {}
        }
        
        # Get flow and port stats for each switch
        for dpid in switches:
            stats['flows'][dpid] = requests.get(
                f"{RYU_API}/stats/flow/{dpid}"
            ).json()
            stats['ports'][dpid] = requests.get(
                f"{RYU_API}/stats/port/{dpid}"
            ).json()
        
        return jsonify(stats)
    except Exception as e:
        return jsonify({'error': str(e)})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)
EOF

Best Practices 📌

1. Controller redundancy - Use multiple controllers
2. Flow table limits - Monitor switch capacity
3. Security first - Implement TLS between controllers and switches
4. Performance monitoring - Track latency and throughput
5. Backup configurations - Save flow rules and topology

Troubleshooting 🔧

Controller Connection Issues

# Check OVS controller status
ovs-vsctl show

# Set controller manually
ovs-vsctl set-controller br0 tcp:127.0.0.1:6653

# Check controller logs
tail -f /var/log/ryu/ryu.log

Flow Installation Problems

# Dump all flows
ovs-ofctl dump-flows br0

# Add flow manually
ovs-ofctl add-flow br0 "priority=100,ip,nw_dst=10.0.0.1,actions=output:1"

# Delete all flows
ovs-ofctl del-flows br0

Quick Commands 📋

# Show OVS configuration
ovs-vsctl show

# List bridges
ovs-vsctl list-br

# Show flows
ovs-ofctl dump-flows br0

# Monitor traffic
ovs-ofctl dump-ports br0

# Run controller
ryu-manager simple_switch.py

# Test connectivity
ip netns exec host1 ping host2

Conclusion 🎯

You’ve successfully built a Software-Defined Network on Alpine Linux! With programmable switches, intelligent controllers, and network virtualization, you now have complete control over your network behavior through software. SDN opens up endless possibilities for network innovation. Happy networking! 🌐✨