Software Defined Networking Final Year Projects

Specifically for final-year projects, we propose a wide range of topics on the subject of SDN (Software-Defined Networking). For the sake of various competency stages, these mentioned project topics are differed in problems and area of interest in SDN domain:

  1. SDN-Based Load Balancer
  • Aim: It mainly utilizes an SDN controller to execute an effective load balancer.
  • Explanation:
  • Develop a network topology by making use of Mininet.
  • In a controller like floodlight, Ryu or POX, apply a custom SDN application.
  • For load balancing, deploy Least Connection, Weighted round-Robin and Round-Robin algorithms.
  • Metrics to Evaluate:
  • Load distribution, Throughput and Latency.
  1. QoS Management with SDN
  • Aim: With the help of an SDN controller, it intends to design a QoS management model.
  • Explanation:
  • A network topology needs to be generated in Mininet.
  • To classify traffic like Video or VoIP, execute a traffic classification application.
  • As regards QoS management, employ OpenFlow rules.
  • Metrics to Evaluate:
  • Jitter, Response Time, Bandwidth and Packet Loss.
  1. Anomaly Detection in SDN Networks
  • Aim: Through SDN controllers, identify the outliers by using gathered flow statistics.
  • Explanation:
  • In order to simulate a network topology, use Mininet.
  • On the SDN controller such as Ryu or POX, design an outlier detection module.
  • Detect abnormal traffic through implementing machine learning frameworks such as SVM or Random Forest techniques.
  • Metrics to Evaluate:
  • False positives, Network Throughput and Detection Rate.
  1. SDN-Based Firewall Implementation
  • Aim: A dynamic firewall needs to be implemented by acquiring the benefit of OpenFlow rules, which is the main focus of research.
  • Explanation:
  • It is required to design a topology in Mininet.
  • In an SDN controller like Floodlight or Ryu, create a firewall module.
  • According to IP addresses and ports, enable or block traffic by implementing flow rules.
  • Metrics to Evaluate:
  • Precision, Packet Filtering Rate and Response Time.
  1. Traffic Engineering using Segment Routing in SDN
  • Aim: For the purpose of effective traffic engineering in an SDN environment, execute segment routing.
  • Explanation:
  • Configure the SDN network topology in Mininet.
  • A Segment Routing module has to be formulated in the SDN controller like OpenDaylight.
  • On the basis of response time and bandwidth necessities, execute traffic engineering strategies.
  • Metrics to Evaluate:
  • Bandwidth distribution, Latency and Path deployment.
  1. Multi-Controller SDN Network Architecture
  • Aim: This project mainly emphasizes the execution and estimation of multi-controller SDN architecture.
  • Explanation:
  • Diverse SDN controllers such as Ryu, Floodlight and ONOS should be configured.
  • Along with several switches and hosts, design a Mininet topology.
  • Inter-controller cooperation and load balancing required to be carried out.
  • Metrics to Evaluate:
  • Scalability, Breakdown time and Controller latency.
  1. SDN-Based Intrusion Detection System (IDS)
  • Aim: Apply SDN for actual-time traffic monitoring by generating an IDS (Intrusion Detection system).
  • Explanation:
  • In Mininet, build a network topology.
  • Regarding the SDN controllers such as OpenDaylight and Ryu, establish an IDS module.
  • To identify and prevent heavy traffic, perform the flow rules.
  • Metrics to Evaluate:
  • Mitigation time, false Positives and Detection Rate.
  1. Network Virtualization with SDN
  • Aim: By employing SDN, accomplish a network virtualization model.
  • Explanation:
  • To build a virtual network management, make use of Mininet.
  • Particularly in the SDN controller, apply a virtual network manager.
  • Classify the traffic into virtual networks by establishing OpenFlow rules.
  • Metrics to Evaluate:
  • Response Time, Scalability and Isolation capability.
  1. Intent-Based Networking in SDN
  • Aim: For automated network control, create an IBN (Intent-Based Networking) system.
  • Explanation:
  • In Mininet, an SDN network topology needs to be developed.
  • Through the controller, translate superior intents into OpenFlow rules.
  • Considering the SDN controller like OpenDaylight, formulate an intent-based application.
  • Metrics to Evaluate:
  • Policy implementation time, Response time and Intent Compliance Rate.
  1. SDN-Based Network Monitoring and Visualization
  • Aim: With the help of an SDN controller, observe the network traffic and visualize it in a dynamic manner.
  • Explanation:
  • Apply sFlow or NetFlow support to configure an SDN controller.
  • Network traffic data must be gathered and accumulated efficiently in a database.
  • For actual-time visualization, create a web-based dashboard.
  • Metrics to Evaluate:
  • Flow Count, traffic volumes and Bandwidth consumption.
  1. OpenFlow-Based Dynamic Network Access Control
  • Aim: It significantly employs OpenFlow rules to execute effective network access management.
  • Explanation:
  • In Mininet, develop a network topology.
  • Depending on built-in policies, access or block the users by establishing flow rules.
  • Particularly in an SDN controller like POX, a network access control application has to be created.
  • Metrics to Evaluate:
  • Access Control Latency, Precision and Policy Compliance Rate.
  1. Programmable Data Plane with P4 and SDN
  • Aim: For SDN switches make use of P4 to develop a programmable data plane.
  • Explanation:
  • Use BMv2 (P4 software switch) to design a Mininet network.
  • Specifically for custom packet forwarding, write a P4 program.
  • Through an SDN controller, manage the P4 switch.
  • Metrics to Evaluate:
  • Portability, Throughput and Packet Processing Latency.

Are there any mini projects for graduate students related to Openflow Mininet Ryu?

Yes! There are numerous mini projects on Ryu, OpenFlow and Mininet available for graduate students. Some of the feasible mini project ideas along with sample program on Mininet, OpenFlow and Ryu are offered by us:

  1. Simple L2 Switch with Ryu and OpenFlow
  • Main Goal: By means of OpenFlow rules and Ryu controller, it intends to apply basic Layer 2 switch.
  • Definitions:
  • In mininet, build a basic network topology.
  • Depending on MAC addresses, forward the packets by designing a basic switch application.
  • To manage familiar and unfamiliar locations, employ OpenFlow rules.
  • Skills Acquired:
  • Ryu application formation and OpenFlow rule management are the encompassed skills.
  • Sample code of Ryu (simple-switch.py):

# simple_switch.py

From ryu.base import app_manager

From ryu.controller import ofp_event

From ryu.controller.handler import MAIN_DISPATCHER, CONFIG_DISPATCHER, set_ev_cls

From ryu.ofproto import ofproto_v1_3

From ryu.lib.packet import packet, Ethernet

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):

Datapath = ev.msg.datapath

Ofproto = datapath.ofproto

Parser = datapath.ofproto_parser

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, and buffer_id=None):

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):

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]

DST = eth.dst

Src = eth.src

Dpid = datapath.id

self.mac_to_port.setdefault (dpid, {})

self.mac_to_port [dpid][src] = in_port

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)]

If out_port!= ofproto.OFPP_FLOOD:

Match = parser.OFPMatch (in_port=in_port, eth_dst=dst)

self.add_flow (datapath, 1, match, actions)

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)

Execute the Ryu Controller:

Ryu-manager simple_switch.py

Build Mininet Topology:

# Create a simple Mininet topology

Sudo MN –controller=remote, ip=127.0.0.1, port=6633 –switch ovs, protocols=OpenFlow13 –topo single, 3 –mac

  1. Traffic Monitoring Application Using OpenFlow and Ryu
  • Main Goal: This project efficiently utilizes flow statistics to create a traffic monitoring application.
  • Definitions:
  • A mininet network topology should be developed.
  • From switches, gather the flow statistics by generating a Ryu application with the help of OpenFlow.
  • Traffic data must be recorded and evaluated.
  • Skills Acquired:
  • It includes skills like Traffic monitoring and collection of flow statistics.
  • Ryu code sample (traffic_ monitor.py):

# traffic_monitor.py

From ryu.base import app_manager

From ryu.controller import ofp_event

From ryu.controller.handler import MAIN_DISPATCHER, set_ev_cls

From ryu.ofproto import ofproto_v1_3

Class TrafficMonitor (app_manager.RyuApp):

OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

Def __init__(self, *args, **kwargs):

Super (TrafficMonitor, self).__init__(*args, **kwargs)

self.datapaths = {}

@set_ev_cls (ofp_event.EventOFPStateChange, [MAIN_DISPATCHER])

Def _state_change_handler (self, ev):

Datapath = ev.datapath

If ev. States == MAIN_DISPATCHER:

self.datapaths [datapath.id] = datapath

Self. Request stats (datapath)

Def _request_stats (self, datapath):

Ofproto = datapath.ofproto

Parser = datapath.ofproto_parser

Req = parser.OFPFlowStatsRequest (datapath)

datapath.send_msg (req)

@set_ev_cls (ofp_event.EventOFPFlowStatsReply, MAIN_DISPATCHER)

Def _flow_stats_reply_handler (self, ev):

Body = ev.msg.body

For stat in sorted ([flow for flow in body if flow.priority == 1], key=lambda x: (x.match [‘in_port’], x.match [‘eth_dst’])):

self.logger.info (“Flow: %s”, stat)

Execute the Ryu Controller:

Ryu-manager traffic_monitor.py

  1. Basic Firewall Implementation Using OpenFlow and Ryu
  • Main Goal: In accordance with IP addresses, this project significantly concentrates on developing simple firewall architecture to enable or restrict the traffic.
  • Definitions:
  • Generate a network topology.
  • Use OpenFlow rules to create a Ryu application for the process of accessing or restricting the Ip addresses.
  • Skills Acquired:
  • Security policy application and OpenFlow rule management could be the gained expertise.
  • Model Code of Ryu (simple-firewall.py)

# simple_firewall.py

From ryu.base import app_manager

From ryu.controller import ofp_event

From ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER, set_ev_cls

From ryu.ofproto import ofproto_v1_3

From ryu.lib.packet import packet, ethernet, ipv4

Class Simple Firewall (app_manager.RyuApp):

OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

BLOCKED_IPS = [‘10.0.0.2’]

Def __init__(self, *args, **kwargs):

Super (SimpleFirewall, self).__init__(*args, **kwargs)

@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

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, and buffer_id=None):

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):

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 == 0x0800:  # IPv4

Ip = pkt.get_protocols (ipv4.ipv4)[0]

If ip.src in self.BLOCKED_IPS or ip.dst in self.BLOCKED_IPS:

self.logger.info (“Blocking packet from %s to %s”, ip.src, ip.dst)

Return

Actions = [parser.OFPActionOutput (ofproto.OFPP_FLOOD)]

Match = parser.OFPMatch (in_port=in_port)

Data = None

If msg.buffer_id == ofproto.OFP_NO_BUFFER:

Data = msg.data

Out = parser.OFPPacketOut (datapath=datapath, buffer_id=msg.buffer_id, in

Software Defined Networking Final Year Topics

Software Defined Networking Final Year Thesis Topics

If you are currently in your final year and encountering difficulties with your SDN topic, phdprojects.org is the ideal company to turn to for exceptional services customized to meet your specific needs. We offer a wide range of Software Defined Networking Final Year Thesis Topics that we are actively working on, and we have successfully provided scholars with outstanding implementation support. Feel free to reach out to us and share all your requirements.

  1. MARVEL: Enabling controller load balancing in software-defined networks with multi-agent reinforcement learning
  2. An adaptive heuristic for multi-objective controller placement in software-defined networks
  3. Software defined networking (SDN) over space division multiplexing (SDM) optical networks: features, benefits and experimental demonstration
  4. Towards the tactile internet: Decreasing communication latency with network coding and software defined networking
  5. Machine learning and deep learning based traffic classification and prediction in software defined networking
  6. Spartacus: Service priority adaptiveness for emergency traffic in smart cities using software-defined networking
  7. Simplifying network management using software defined networking and OpenFlow
  8. Enduring node failures through resilient controller placement for software defined networks
  9. Selective packet inspection to detect DoS flooding using software defined networking (SDN)
  10. A self-adaptive virtual network embedding algorithm based on software-defined networks
  11. Security and Privacy Issues in Software-Defined Networking (SDN): A Systematic Literature Review
  12. Container-based network function virtualization for software-defined networks
  13. Open transport switch: a software defined networking architecture for transport networks switch: a software defined networking architecture for transport networks
  14. SecSDN-cloud: defeating vulnerable attacks through secure software-defined networks
  15. Jupiter evolving: transforming google’s datacenter network via optical circuit switches and software-defined networking
  16. Cyber resilience protection for industrial internet of things: A software-defined networking approach
  17. A fast consensus algorithm for multiple controllers in software-defined networks
  18. An effective hierarchical control plane for software-defined networks leveraging TOPSIS for end-to-end QoS class-mapping
  19. Software-defined network forensics: Motivation, potential locations, requirements, and challenges
  20. Quality of Service Guaranteed Resource Management Dynamically in Software Defined Network.