Mininet

Introduction to Mininet

Mininet is a network emulator that creates a network of virtual hosts, switches, controllers, and links. It supports OpenFlow for software-defined networking (SDN) and allows you to run real Linux network software on a single machine [7]. Mininet is widely used for research, development, learning, prototyping, testing, and debugging network applications [8].

Main Features

1. Network Emulation: Mininet creates a network of virtual hosts, switches, controllers, and links, allowing you to run real Linux network software on a single machine [7].

2. OpenFlow Support: It supports OpenFlow, enabling highly flexible custom routing and software-defined networking (SDN) [3].

3. Lightweight Virtualization: Mininet uses lightweight containers (network namespaces) instead of full virtual machines, which allows for the creation of large networks with minimal resource consumption [7].

4. Realistic Network Topologies: You can create realistic network topologies and test them in a controlled environment [2].

5. Extensive CLI and API: Mininet provides a command-line interface (CLI) and a Python API for easy network creation, management, and automation [2].

6. Integration with Tools: It integrates well with other network tools like Wireshark for packet analysis and debugging [2].

Advanced Features

1. Custom Topologies: Mininet allows you to create custom network topologies using Python scripts, enabling complex and specific network configurations [2].

2. Link Variations: You can emulate different link characteristics such as bandwidth, delay, and packet loss to test network performance under various conditions [2].

3. Multiple Controllers: Mininet supports multiple controllers, including remote controllers, which allows for testing distributed control scenarios [2].

4. XTerm Integration: You can open terminal windows for each host and switch, providing a convenient way to interact with the network elements [2].

5. Benchmarking: Mininet includes benchmarking tools to measure the performance of the network and its components [2].

Use Cases

1. Research and Development: Enabling experimentation with new network services and protocols, such as OpenFlow case studies [1].

2. Education: Providing a hands-on learning environment for students to understand networking concepts and SDN [3].

3. Prototyping and Testing: Allowing developers to prototype and test network applications and configurations before deploying them in a real-world environment [1].

4. Network Function Virtualization (NFV): Implementing and testing NFV scenarios, such as virtualized network functions and service chaining [1].

Installing Mininet

Mininet runs on Linux-based systems and requires Python and a few other dependencies. This guide will focus on installing Mininet on Ubuntu. For other distributions, refer to the official Mininet documentation [8]. Here are the steps to install Mininet on Ubuntu:

1. Update your package list:

   sudo apt update
   

2. Install Mininet:

   sudo apt install mininet
   

3. Install Open vSwitch Test Controller:

   sudo apt install openvswitch-testcontroller
   

4. Verify the installation:

   sudo mn --test pingall
   

This will create a simple network and test connectivity between hosts.

Mininet CLI [9]

Mininet provides a command-line interface (CLI) that allows you to interact with the network elements and perform various operations. The Mininet CLI is a powerful tool for creating, managing, and testing network topologies. Here are some common commands and operations you can perform using the Mininet CLI:

Exercise 1: Basic Commands in Mininet

Objective: Learn the basic commands in Mininet.

Steps: 1. Start a simple network topology:

$ sudo mn

2. List the nodes in the network:

   mininet> nodes
   

3. Display the links in the network:

   mininet> net
   

4. Test connectivity between hosts:

   mininet> pingall
   

Exercise 2: Teardown and Cleanup

Objective: Learn how to teardown and cleanup a Mininet network.

Steps: 1. Start a simple network topology:

$ sudo mn

2. Stop the network and cleanup resources:

   mininet> exit
   

3. Verify that the network has been stopped and resources have been cleaned up.

   $ sudo mn -c
   

Exercise 3: Exploring Network Topology

Objective: Use Mininet CLI commands to explore the network topology.

Steps: 1. Start a simple network topology:

sudo mn

2. Display the network topology:

   mininet> net
   

3. List the ports in the network:

   mininet> ports
   

4. List the links in the network:

   mininet> links
   

Exercise 4: Running Commands on Hosts

Objective: Run various commands on hosts using the Mininet CLI.

Steps: 1. Start a simple network topology:

$ sudo mn

2. Run a command on a specific host:

   mininet> h1 ifconfig
   

3. Run a ping test between two hosts:

   mininet> h1 ping -c 3 h2
   

4. Run a bandwidth test between two hosts:

   mininet> iperf h1 h2
   

Exercise 5: Configuring Link Parameters

Objective: Configure link parameters such as bandwidth, delay, and loss using the Mininet CLI.

Steps: 1. Start a simple network topology:

sudo mn --link tc,bw=10,delay=5ms,loss=1

In the above command, we set the bandwidth to 10 Mbps, delay to 5 ms, and packet loss to 1%.

2. Test connectivity and observe the effects of the link parameters:

   mininet> pingall
   

3. Run a bandwidth and latency test between the two hosts:

   mininet> iperfudp
   mininet> h1 ping -c 10 h2
   

Exercise 6: Using XTerm for Hosts

Objective: Open XTerm windows for hosts to interact with them using a graphical interface.

Steps: 1. Start a simple network topology:

sudo mn

2. Open an XTerm window for a specific host:

   mininet> xterm h1
   

3. Run commands in the XTerm window on the host h1:

   ifconfig
   ping -c 3 h2
   

4. Alternatively, you can open XTerm windows automatically using the mn command:

   $ sudo mn --xterms
   

Exercise 7: Capturing Packets with Wireshark

Objective: Capture and analyze network packets using Wireshark.

Steps: 1. Start a simple network topology:

sudo mn

2. Start Wireshark on a specific interface:

   mininet> h1 wireshark &
   

3. Capture packets and analyze them in Wireshark.

Mininet Python API

Exercise 1: Creating Custom Topologies

Objective: Learn how to create custom network topologies in Mininet.

Steps: 1. Create a Python script to define a custom topology:

mytopo.py

from mininet.topo import Topo
from mininet.net import Mininet
from mininet.cli import CLI
from mininet.node import OVSController

class MyTopo(Topo):
    """
    A simple topology with two hosts and one switch.

    Methods
    -------
    build():
        Builds the network topology by adding hosts and switches and linking them.
    """
    def build(self):
        """
        Build the network topology.

        Adds two hosts and one switch, then creates links between the hosts and the switch.
        """
        h1 = self.addHost('h1')
        h2 = self.addHost('h2')
        s1 = self.addSwitch('s1')
        self.addLink(h1, s1)
        self.addLink(h2, s1)

if __name__ == '__main__':
    """
    Main function to create and start the Mininet network.

    Creates an instance of the MyTopo class, initializes the Mininet network with the topology and a default controller,
    starts the network, and opens the Mininet CLI for user interaction. Stops the network after exiting the CLI.
    """
    topo = MyTopo()
    net = Mininet(topo=topo, controller=OVSController)
    net.start()
    CLI(net)
    net.stop()

2. Run the script to start the custom topology:

   sudo python3 mytopo.py
   

3. Test connectivity between hosts using the Mininet CLI:

   mininet> pingall
   

Exercise 2: Emulating Link Characteristics

Objective: Emulate different link characteristics such as bandwidth, delay, and packet loss.

Steps: 1. Create a Python script to define a topology with link characteristics:

linktopo.py

from mininet.topo import Topo
from mininet.net import Mininet
from mininet.link import TCLink
from mininet.cli import CLI
from mininet.node import OVSController

class LinkTopo(Topo):
    """
    A topology with two hosts and one switch, using TCLink to specify link parameters.

    Methods
    -------
    build():
        Builds the network topology by adding hosts and switches and linking them with specified parameters.
    """
    def build(self):
        """
        Build the network topology.

        Adds two hosts and one switch, then creates links between the hosts and the switch with specified bandwidth, delay, and packet loss.
        """
        h1 = self.addHost('h1')
        h2 = self.addHost('h2')
        s1 = self.addSwitch('s1')
        self.addLink(h1, s1, cls=TCLink, bw=10, delay='5ms', loss=1)
        self.addLink(h2, s1, cls=TCLink, bw=10, delay='5ms', loss=1)

if __name__ == '__main__':
    """
    Main function to create and start the Mininet network.

    Creates an instance of the LinkTopo class, initializes the Mininet network with the topology, TCLink for link parameters, and a default controller.
    Starts the network, opens the Mininet CLI for user interaction, and stops the network after exiting the CLI.
    """
    topo = LinkTopo()
    net = Mininet(topo=topo, link=TCLink, controller=OVSController)
    net.start()
    CLI(net)
    net.stop()

1. Run the script to start the topology with link characteristics:

   sudo python3 linktopo.py
   

2. Test connectivity and observe the effects of the link characteristics:

   mininet> pingall
   

Exercise 3: Using Multiple Controllers

Objective: Configure and use multiple controllers in Mininet.

Steps: 1. Create a Python script to define a topology with multiple controllers:

multicontroller.py

from mininet.topo import Topo
from mininet.net import Mininet
from mininet.node import RemoteController
from mininet.cli import CLI

class MultiControllerTopo(Topo):
    """
    A topology with two hosts and one switch, using multiple remote controllers.

    Methods
    -------
    build():
        Builds the network topology by adding hosts and switches and linking them.
    """
    def build(self):
        """
        Build the network topology.

        Adds two hosts and one switch, then creates links between the hosts and the switch.
        """
        h1 = self.addHost('h1')
        h2 = self.addHost('h2')
        s1 = self.addSwitch('s1')
        self.addLink(h1, s1)
        self.addLink(h2, s1)

if __name__ == '__main__':
    """
    Main function to create and start the Mininet network.

    Creates an instance of the MultiControllerTopo class, initializes the Mininet network with the topology and two remote controllers.
    Starts the network, opens the Mininet CLI for user interaction, and stops the network after exiting the CLI.
    """
    topo = MultiControllerTopo()
    c0 = RemoteController('c0', ip='127.0.0.1', port=6633)
    c1 = RemoteController('c1', ip='127.0.0.1', port=6634)
    net = Mininet(topo=topo, controllers=[c0, c1])
    net.start()
    CLI(net)
    net.stop()

2. Run the script to start the topology with multiple controllers:

   sudo python3 multicontroller.py
   

3. Test connectivity and observe the behavior with multiple controllers:

   mininet> pingall
   

Note

Highly Recommended Reading: Mininet Walkthrough [2]

This guide provides a detailed walkthrough of Mininet, including basic commands, custom topologies, advanced features, and Python API usage. It is an excellent resource for beginners to get started with Mininet.

Advanced Network Topologies

Mininet allows you to create complex and realistic network topologies using Python scripts. You can define custom topologies, configure link characteristics, use multiple controllers, and integrate with other tools for network analysis and debugging. Here are some examples of advanced network topologies you can create in Mininet:

1. Fat-Tree Topology: Implement a fat-tree network topology with multiple switches and hosts.

2. Spine-Leaf Topology: Create a spine-leaf network topology with spine and leaf switches.

3. Data Center Network: Emulate a data center network with multiple racks, switches, and hosts.

4. Software-Defined WAN (SD-WAN): Implement an SD-WAN topology with multiple sites and controllers.

5. Network Function Virtualization (NFV): Create an NFV topology with virtualized network functions and service chaining.

6. Internet of Things (IoT) Network: Simulate an IoT network with edge devices, gateways, and cloud servers.

The following exercises demonstrate how to create advanced network topologies in Mininet using Python scripts:

Exercise 4: Fat Tree Topology

In this exercise, you will create a fat tree topology in Mininet using a Python script.

The fat tree topology is a network design that enhances the traditional tree structure by increasing the bandwidth at higher levels of the hierarchy. This design helps to eliminate bottlenecks and improve overall network performance.

Key Characteristics

1. Uniform Bandwidth: Each layer of the network has the same aggregated bandwidth, ensuring that there are no bottlenecks at any point in the network.

2. Scalability: Fat tree topologies can scale efficiently, making them suitable for large data centers and high-performance computing environments.

3. Redundancy and Fault Tolerance: The multiple paths available in a fat tree topology provide redundancy, enhancing fault tolerance and reliability.

4. Cost-Effectiveness: Fat tree networks can be built using commodity switches, which are cheaper and more power-efficient than high-end modular switches.

Applications

Fat tree topologies are commonly used in data centers and supercomputers to ensure efficient and scalable communication. They are particularly well-suited for environments that require high bandwidth and low latency, such as cloud computing and large-scale scientific simulations.

Fat Tree Topology, k=4

Topology Design

Objective: Create a fat tree topology by extending the Topo class.

Steps: 1. Create a Python script to define a fat tree topology:

fattreetopo.py

import sys
from mininet.topo import Topo
from mininet.net import Mininet
from mininet.cli import CLI

class FatTreeTopo(Topo):
    """
    A fat tree topology with a configurable number of pods.

    Methods
    -------
    build(k=4):
        Builds the network topology by adding core, aggregation, and edge switches, and hosts, and linking them.
    """
    def build(self, k=4):
        """
        Build the network topology.

        Parameters
        ----------
        k : int, optional
            The number of pods in the fat tree topology (default is 4).

        Creates core switches, aggregation switches, edge switches, and hosts, and links them according to the fat tree design.
        """
        core_switches = []
        agg_switches = []
        edge_switches = []
        hosts = []

        # Create core switches
        for i in range((k//2)**2):
            core_switches.append(self.addSwitch(f'cs{i+1}'))

        # Create aggregation and edge switches
        for pod in range(k):
            agg_switches.append([])
            edge_switches.append([])
            for i in range(k//2):
                agg_switches[pod].append(self.addSwitch(f'as{pod+1}{i+1}'))
                edge_switches[pod].append(self.addSwitch(f'es{pod+1}{i+1}'))

        # Create hosts and link them to edge switches
        for pod in range(k):
            hosts.append([])
            for i in range(k//2):
                hosts[pod].append([])
                for j in range(k//2):
                    host = self.addHost(f'h{pod+1}{i+1}{j+1}')
                    hosts[pod][i].append(host)
                    self.addLink(host, edge_switches[pod][i])

        # Connect edge switches to aggregation switches
        for pod in range(k):
            for i in range(k//2):
                for j in range(k//2):
                    self.addLink(edge_switches[pod][i], agg_switches[pod][j])

        # Connect aggregation switches to core switches
        for i in range(k//2):
            for j in range(k//2):
                for pod in range(k):
                    self.addLink(agg_switches[pod][i], core_switches[i*(k//2)+j])

if __name__ == '__main__':
    """
    Main function to create and start the Mininet network.

    Checks if the correct number of command-line arguments is provided. If not, prints usage instructions and exits.
    Creates an instance of the FatTreeTopo class with a specified number of pods (k), initializes the Mininet network with the topology,
    starts the network, opens the Mininet CLI for user interaction, and stops the network after exiting the CLI.
    """
    if len(sys.argv) != 2:
        print("Usage: sudo python fattreetopo.py <k>")
        sys.exit(1)

    k = int(sys.argv[1])
    topo = FatTreeTopo(k=k)
    net = Mininet(topo=topo)
    net.start()
    CLI(net)
    net.stop()

2. Run the script with the desired value of k:

   sudo python fattreetopo.py 4
   

3. Use the Mininet CLI to interact with the network:

   mininet> pingall
   

Explanation

In this exercise, you will create a fat tree topology by extending the Topo class in Mininet. The parameter k is made user-configurable by taking it as a command-line argument. The script creates core switches, aggregation switches, edge switches, and hosts, and then links them according to the fat tree design.

Exercise 5: Leaf Spine Topology (Clos)

In this exercise, you will create a leaf-spine (Clos) topology in Mininet using a Python script. The leaf-spine topology is a popular network design for data centers that provides high bandwidth, low latency, and fault tolerance. It consists of two layers: leaf switches and spine switches. The leaf switches are connected to the spine switches, and the hosts are connected to the leaf switches. This design allows for non-blocking, full-mesh connectivity between hosts and provides scalability and redundancy.

Note

Switch oversubscription can create bottlenecks in the network. Therefore, the leaf and spine switch configurations should be carefully planned to avoid congestion.

Key Characteristics

1. Scalability: The leaf-spine topology is highly scalable and can accommodate a large number of hosts and switches.

2. High Bandwidth: The full-mesh connectivity between leaf and spine switches ensures high bandwidth and low latency.

3. Redundancy: The multiple paths between hosts and switches provide redundancy and fault tolerance.

See the data center network lecture for more information on the leaf-spine topology.

Clos Topology

Topology Design

Objective: Create a leaf-spine (Clos) topology by extending the Topo class.

Steps: 1. Import Required Libraries

First, import the necessary libraries for Mininet and network configuration.

from mininet.net import Mininet
from mininet.node import Controller, OVSSwitch
from mininet.link import TCLink
from mininet.cli import CLI
from mininet.log import setLogLevel, info

2. Define the Spine-Leaf Topology Class

   Create a class for the spine-leaf topology. This class will initialize the network and configure the switches and hosts.

   class SpineLeafTopo:
      def __init__(self, num_ports=2):
         self.num_spines = num_spines
         self.num_leaves = num_leaves
         self.net = Mininet(controller=Controller, link=TCLink, switch=OVSSwitch)
   
   
       def build(self):
            info('*** Adding controller\n')
            self.net.addController('c0')
   
            info('*** Adding spine switches\n')
            # Add spine switches logic here.
   
            info('*** Adding leaf switches\n')
            # Add leaf switches logic here.
   
            info('*** Creating links between spine and leaf switches\n')
            # Add links between spine and leaf switches logic here.
   
            info('*** Adding hosts and connecting them to leaf switches\n')
            # Add hosts and connect them to leaf switches logic here.
   
       def start(self):
           self.net.start()
           CLI(self.net)
           self.net.stop()
   

3. Run the Topology

   Instantiate the topology class with user-defined port numbers and build the network.

   if __name__ == '__main__':
       setLogLevel('info')
       num_ports = int(input("Enter the number of ports for each switch: "))
       topo = SpineLeafTopo(num_ports)
       topo.build()
       topo.start()
   

4. Run the script with the desired value of k:

   sudo python spineleaftopo.py
   

5. Use the Mininet CLI to interact with the network:

   mininet> pingall
   

Expected Outcome

By the end of this exercise, you should be able to create a spine-leaf network topology using the Mininet Python API with user-configurable ports for both the spine and leaf switches. You will also gain hands-on experience with Mininet’s CLI for network management.

References

[1] (1,2,3)

Network Topology Implementations in Mininet. Available at: https://github.com/CynicDog/network-topology-implementations-in-mininet

[2] (1,2,3,4,5,6,7,8,9)

Mininet Walkthrough. Available at: http://mininet.org/walkthrough/

[3] (1,2)

Mininet Blog. Available at: http://mininet.org/blog/

[7] (1,2,3)

Mininet Overview. Available at: https://github.com/mininet/mininet/wiki/Introduction-to-Mininet

[8] (1,2)

Mininet Documentation. Available at: https://mininet.org/

[9]

Introduction to Mininet. Available at: https://github.com/mininet/mininet/wiki/Introduction-to-Mininet