Protocols for Data Networks (aka Advanced Computer Networks)

Transcription

1 Protocols for Data Networks (aka Advanced Computer Networks) Deadline: 19 March 2016 Programming Assignment 1: Introduction to mininet The goal of this assignment is to serve as an introduction to the mininet emulator [1][2]. Mininet allows the creation of realistic virtual networks, running real kernel, switch and application code, on a single machine (VM, cloud or native). Mininet is the main tool used to develop, share, and experiment with Software-Defined Networks. 1. Part I Data center networks typically have a tree-like topology. End-hosts connect to top-of-rack switches, which form the leaves (edges) of the tree; one or more core switches form the root; and one or more layers of aggregation switches form the middle of the tree. In a basic tree topology, each switch (except the core switch) has a single parent switch. Additional switches and links may be added to construct more complex tree topologies (e.g., fat tree) [3] in an effort to improve fault tolerance or increase inter-rack bandwidth. This assignment is composed of two parts: using mininet, a) create a simple tree topology; and b) create a more complex fat tree topology. For the first part, consider Figure 1. Assume each level (i.e., core, aggregation, edge and host) to be composed of a single layer of switches/hosts with a configurable fanout 1 (in the figure, we illustrate a fanout of 2). Figure 1: Simple tree topology with fanout 2 1 The fanout of a switch output is the number of other switch/host inputs it can feed.

2 The output of this part of the assignment should be a mininet script that, receiving as input a generic fanout k, creates a tree-based topology. As a first step you can make a mininet script that creates a topology with fanout 2, and then evolve from there to a generic solution. 2. Part II The objective of the second part of the assignment is to create a data center fat tree topology using mininet. A k-ary fat tree is a three-layer topology (edge, aggregation and core) that consists of k pods, with the following characteristics: a) each pod consists of (k/2) 2 servers and 2 layers of k/2 k-port switches b) each edge switch connects to k/2 servers and k/2 aggregation switche c) each aggregation switch connects to k/2 edge and k/2 core switches d) and has (k/2) 2 core switches: each connects to k pods. The objective of this assignment is to create a k-ary fat tree topology. Figure 2 illustrates a 4-ary fat tree, with k=4 Pods. As such, it has k=4 switches in core level, and each Pod contains two layers (aggregation and edge) of k/2=2 switches. Moreover, each k=4-port switch in the lower layer is directly connected to k/2=2 hosts. Each of the remaining k/2=2 ports is connected to k/2=2 of the k ports in the aggregation layer of the hierarchy. Figure 2: Fat Tree Topology with 4 Pods [ 2 ]

3 3. Grading The grades for this assignment will be distributed as follows (out of 20 pts): a) 10 pts for the solution that builds a simple tree topology with fanout 2; b) 4 pts for the solution that builds a simple tree topology with fanout k; and c) 6 pts for the solution that builds a fat tree topology with k Pods. You should deliver 1 mininet script (including topology generation and testing, as explained in the next section) for each one of these tasks. Do not forget to comment your code with the necessary detail. 4. Code to deliver We advise you to start from the skeleton code illustrated below (in this case, for a Simple Tree Topology with Fanout 2): A skeleton class which you will update with the logic for creating the datacenter topologies described above. from mininet.topo import Topo #from mininet.net import Mininet #from mininet.link import TCLink class CustomTopo(Topo): "Simple Data Center Topology" "linkopts - (1:core, 2:aggregation, 3: edge) parameters" "fanout - number of child switch per parent switch" def init (self, linkopts1, linkopts2, linkopts3, fanout=2, **opts): # Initialize topology and default options Topo. init (self, **opts) # Add your logic here... For the Simple Tree Topology with Fanout 2, the skeleton class takes the following arguments as input: linkopts1: for specifying performance parameters for the links between core and aggregation switches. linkopts2: for specifying performance parameters for the links between aggregation and edge switches. linkopts3: for specifying performance parameters for the links between edge switches and host Fanout: to specify the fanout value i.e., the number of childs per node. Your logic should support setting at least bandwidth, delay and loss packet parameters for each link. [ 3 ]

4 For the Fat Tree Topology with k Pods, the the skeleton class should be changed to take the following arguments as input: linkopts1 = linkopts2 = linkopts3: for specifying performance parameters for the links between every switch (the design of the topology considers they have the same value). Pods: replace the Fanout parameter for the Pods parameter to specify the number of Pods to be considered in the topology. Your logic should support setting at least the bandwidth, delay and loss packet parameters for each link. In addition to writing the code necessary for mininet to generate the tree-like topologies, the students should include in their code (or deliver as an additional script) tests that enable making the following experiments: 1. Using iperf, the test script should demonstrate the achieved throughput between selected hosts. As an example, in the Simple Tree Topology with Fanout 2, the students could set the links between the core and aggregation to 20Mbps, between the hosts and edge switches to 10Mbps, and 1Mbps between edge and aggregation switches. Then, they could generate traffic between selected hosts to show that the performance results are as expected. As another example, in the Fat Tree Topology with 4 Pods the students could set all links to 10Mbps. Then, they could generate traffic between selected hosts to show the performance results. The code should be commented with the expected results. 2. Using the ping command, the test script should demonstrate the delay between selected hosts. The students should set different delays for specific links, and by using the ping command show that the performance results are as expected. Again, the code should be commented with the expected results. 3. Perform the same experiments as in 2), but changing the loss parameter to 10% to selected links. You guessed it: the code should be commented with the expected results. [ 4 ]

5 5. Mininet: a few examples to get you started In this section you will be learning how to build custom topologies using Mininet Python API [4,5] and how certain parameters like bandwidth, delay, loss and queue size can be set individually for different links in the topology. You ll also learn how to do performance testing of these custom topologies using ping and iperf. Overview The network you'll use in this exercise includes hosts and switches connected in a linear topology, as shown in the figure below. Creating Topology Figure 1: hosts and switches connected in a linear topoloy Mininet supports parametrized topologies. With a few lines of Python [6,7] code, you can create a flexible topology that can be configured based on the parameters you pass into it, and reused for multiple experiments. For example, here is a simple network topology (based on Figure 1), which consists of a specified number of hosts (h1 through hn) connected to their individual switches (s1 through sn): #!/usr/bin/python Linear Topology (without Performance Settings) from mininet.topo import Topo from mininet.net import Mininet from mininet.util import irange,dumpnodeconnections from mininet.log import setloglevel # Below is the base class and its inherits (or extend) Topo from mininet.topo class LinearTopo(Topo): "Linear topology of k switches, with one host per switch." [ 5 ]

6 # Constructor method (**opts receives arguments named from a dictionary) def init (self, k=2, **opts): """Init. k: number of switches (and hosts) hconf: host configuration options lconf: link configuration options""" # Required when using "topo" library super(lineartopo, self). init (**opts) self.k = k # The value None in lastswitch variable assignment is frequently # used to represent the absence of a value lastswitch = None for i in irange(1, k): host = self.addhost('h%s' % i) switch = self.addswitch('s%s' % i) self.addlink( host, switch) if lastswitch: self.addlink( switch, lastswitch) lastswitch = switch def simpletest(): "Create and test a simple network" topo = LinearTopo(k=4) net = Mininet(topo) net.start() print "Dumping host connections" dumpnodeconnections(net.hosts) print "Testing network connectivity" net.pingall() net.stop() if name == ' main ': # Tell mininet to print useful information setloglevel('info') simpletest() The important classes, methods, functions and variables in the above code include: Topo: the base class for Mininet topologies addswitch(): adds a switch to a topology and returns the switch name. In this example, four switches were added. addhost(): adds a host to a topology and returns the host name. In this case, four hosts were added. [ 6 ]

7 addlink(): adds a bidirectional link to a topology (and returns a link key, but this is not important). Links in Mininet are bidirectional unless noted otherwise. mininet: main class to create and manage a network start(): starts your network pingall(): tests connectivity by trying to have all nodes ping each other stop(): stops your network net.hosts: all the hosts in a network dumpnodeconnections(): dumps connections to/from a set of nodes. setloglevel( 'info' 'debug' 'output' ): set Mininet's default output level; 'info' is recommended as it provides useful information. Additional example code may be found in mininet/examples. 2 Setting Performance Parameters In addition to basic behavioral networking, Mininet provides performance limiting and isolation features, through the CPULimitedHost and TCLink classes. There are multiple ways that these classes may be used, but one simple way is to specify them as the default host and link classes/constructors to Mininet(), and then to specify the appropriate parameters in the topology. #!/usr/bin/python Linear Topology (with Performance Settings) from mininet.topo import Topo from mininet.net import Mininet from mininet.node import CPULimitedHost from mininet.link import TCLink from mininet.util import irange,dumpnodeconnections from mininet.log import setloglevel class LinearTopo(Topo): "Linear topology of k switches, with one host per switch." def init (self, k=2, **opts): """Init. k: number of switches (and hosts) hconf: host configuration options lconf: link configuration options""" super(lineartopo, self). init (**opts) self.k = k 2 Path of the install directory of Mininet or [ 7 ]

8 lastswitch = None for i in irange(1, k): host = self.addhost('h%s' % i, cpu=.5/k) switch = self.addswitch('s%s' % i) # 10 Mbps, 5ms delay, 1% loss, 1000 packet queue self.addlink( host, switch, bw=10, delay='5ms', loss=1, max_queue_size=1000, use_htb=true) if lastswitch: self.addlink(switch, lastswitch, bw=10, delay='5ms', loss=1, max_queue_size=1000, use_htb=true) lastswitch = switch def perftest(): "Create network and run simple performance test" topo = LinearTopo(k=4) net = Mininet(topo=topo, host=cpulimitedhost, link=tclink) net.start() print "Dumping host connections" dumpnodeconnections(net.hosts) print "Testing network connectivity" net.pingall() print "Testing bandwidth between h1 and h4" h1, h4 = net.get('h1', 'h4') net.iperf((h1, h4)) net.stop() if name == ' main ': setloglevel('info') perftest() Some important methods and parameters: self.addhost(name, cpu=f): This allows you to specify a fraction of overall system CPU resources which will be allocated to the virtual host. self.addlink( node1, node2, bw=10, delay='5ms', max_queue_size=1000, loss=1, use_htb=true): adds a bidirectional link with bandwidth, delay and loss characteristics, with a maximum queue size of 1000 packets using the Hierarchical Token Bucket rate limiter and netem delay/loss emulator. The parameter bw is expressed as a number in Mb/s; delay is expressed as a string with units in place (e.g. '5ms', '100us', '1s'); loss is expressed as a percentage (between 0 and 100); and max_queue_size is expressed in packets. net.get(): retrieves a node (host or switch) object by name. This is important if you want to send a command to a host (e.g. using host.cmd()) and get its output. In the current master branch of Mininet, you can simply use braces (e.g. net['h1']) to retrieve a given node by name. [ 8 ]

9 net.iperf((h1, h4)): this command ran an iperf server on one host (h1), ran an iperf client on the second host (h4), and parsed the bandwidth achieved. You may find it useful to create a Python dictionary to make it easy to pass the same parameters into multiple method calls, for example: linkopts = dict(bw=10, delay='5ms', loss=1, max_queue_size=1000, use_htb=true) alternately: linkopts = {'bw':10, 'delay':'5ms', 'loss':1, 'max_queue_size':1000, 'use_htb':true} self.addlink(node1, node2, **linkopts) Running in Mininet To run the custom topology (linear with four switches/hosts) you have created above, follow the instructions below: Create a LinearTopo.py script on your Mininet VM (or other) and copy the contents of Linear Topology (without Performance Settings), listed above in it. Make the script executable: $ chmod u+x LinearTopo.py Execute the script: $ sudo./lineartopo.py Output: *** Creating network *** Adding controller *** Adding hosts: h1 h2 h3 h4 *** Adding switches: s1 s2 s3 s4 *** Adding links: (h1, s1) (h2, s2) (h3, s3) (h4, s4) (s1, s2) (s2, s3) (s3, s4) *** Configuring hosts h1 h2 h3 h4 *** Starting controller *** Starting 4 switches s1 s2 s3 s4 Dumping host connections h1 h1-eth0:s1-eth1 h2 h2-eth0:s2-eth1 h3 h3-eth0:s3-eth1 h4 h4-eth0:s4-eth1 Testing network connectivity *** Ping: testing ping reachability h1 -> h2 h3 h4 h2 -> h1 h3 h4 h3 -> h1 h2 h4 [ 9 ]

10 h4 -> h1 h2 h3 *** Results: 0% dropped (0/12 lost) *** Stopping 4 hosts h1 h2 h3 h4 *** Stopping 4 switches s1...s2...s3...s4... *** Stopping 1 controllers c0 *** Done 6. References [1] [2] Nikhil Handigol, Brandon Heller, Vimal Jeyakumar, Bob Lantz, and Nick McKeown. Reproducible Network Experiments using Container-Based Emulation. CoNEXT 2012 [3] Mohammad Al-Fares, Alexander Loukissas, and Amin Vahdat, A Scalable, Commodity Data Center Network Architecture, SIGCOMM 08 [4] Mininet Python API [5] Introduction to Mininet [6] Python Offical Web Site [7] Python Books (lots of Python programming material) [ 10 ]