Ecole supérieure privée d’Ingénieurs de Monastir AU : 2021/2022

Niveau d’Etude : 3_LCE-IRS AU : 2020/2021

TP N° 1 : Mise en place d’une
Matière : Virtualisation des Dr. Oussama Ben Haj
architecture réseaux virtuel sous
réseaux mininet Belkacem
Nombre des pages : 07

1- Introduction et objectif :
Ce TP a pour but de vous présenter Mininet, une solution logicielle, qui vous permettra de
mettre en place des topologies réseau au plus proche des besoins de vos tests, simplement.

Mininet est également une solution de SDN, puisqu’il permet de manipuler des ressources
réseau grâce à une API (une librairie Python dans notre cas).

2- Configuration initiale
- Télécharger mininet-VM : Mininet-VM image (Ubuntu.20.04)
Installer VirtualBox

3- Notions de base
a- Pour une première utilisation de l’outil nous pouvons simplement lancer :
sudo mn
b- A ce stade, si vous obtenez le message suivant :
c- Eteindre le contrôleur SDN de test d’OpenVSwitch avant de continuer :

sudo systemctl stop openvswitch-testcontroller

d- Une fois Mininet lancé, nous devrions avoir cet output :

*** Creating network

*** Adding controller
*** Adding hosts:
h1 h2
*** adding switch
S1
** Adding links:
(h1, s1) (h2, s1)
*** Configuring hosts
h1 h2 ***

1
Ecole supérieure privée d’Ingénieurs de Monastir AU : 2021/2022

Starting controller
c0
*** Starting 1 switches
s1 ...
*** Starting CLI:
mininet>

Nous voyons ici que Mininet crée deux “hôtes virtuels” qui sont en réalité des network
namespaces. Mininet utilise cette fonctionnalité du noyau pour permettre à différents
processus de disposer d’interfaces réseau, et de tables de routage distinctes, sur la même
machine.

e- La cli de Mininet nous permet de lister les éléments provisionnés (ou nodes) :

f- Nous pouvons exécuter des commandes sur chaque noeud. Regardons les interfaces
réseau disponibles sur chaque host et interpréter les résultats ( mininet> h1et h2 ip
a)
g- Mininet facilite la communication entre les différents noeuds. Exemple, nous pouvons
pinger directement h2 depuis h1 de cette façon :

h- Il est donc très simple de tester une application web, par exemple. Il suffit pour cela
de lancer le serveur sur l’un des hosts et de lancer des requêtes depuis un autre host
qui jouera le rôle de client :

2
Ecole supérieure privée d’Ingénieurs de Monastir AU : 2021/2022

i- Mininet est également très utile pour tester des applications distribuées, puisqu’il
permet de déployer de nombreux noeuds, au sein d’une topologie que l’on aura
choisie. Voyons justement comment déployer une topologie plus complexe, depuis la
ligne de commande. Mininet dispose de topologies type, que l’on peut utiliser
simplement, exemple avec la topologie linear (n hosts, un switch par host, tous les
switchs sont connectés, le même sous-réseau est utilisé) :

j- Nous avons vu les bases de l’utilisation de Mininet. Voyons maintenant ce qui fait sa
plus-value. Nous pouvons induire de la latence, ou réduire la bande passante des
différents liens, ce qui peut être très pratique pour tester les performances de nos
applications dans un contexte réaliste :

sudo mn --link tc,bw=10,delay=10ms

*** Creating network
*** Adding controller
*** Adding hosts:
h1 h2
*** Adding switches:
s1

3
Ecole supérieure privée d’Ingénieurs de Monastir AU : 2021/2022

*** Adding links:

(10.00Mbit 10ms delay) (10.00Mbit 10ms delay) (h1, s1)
(10.00Mbit 10ms delay) (10.00Mbit 10ms delay) (h2, s1)
*** Configuring hosts
h1 h2
*** Starting controller
c0
*** Starting 1 switches
s1 ...(10.00Mbit 10ms delay) (10.00Mbit 10ms delay)

k- Il est également possible de couper les liens entre nos machines, très pratique pour
tester la résilience d’une application distribuée par exemple :

l- Utiliser l’”API” Python

Nous avons exploré les fonctionnalités de base de Mininet. Mais cet outil est bien plus
puissant (et automatisable) si l’on programme avec. Il nous est alors possible de créer des
topologies dynamiques, d’y inclure des routeurs, des firewalls, des proxys, etc…

a- Voici un exemple basique, dans lequel nous définissions un noeud routeur, qui aura
une interface dans deux sous-réseaux différents. Chaque réseau comprend un switch
et un host.

#!/usr/bin/python

from mininet.node import OVSController

from mininet.net import Mininet
from mininet.cli import CLI
from mininet.log import lg, info
from mininet.node import Node
from mininet.topolib import TreeTopo
from mininet.topo import Topo
from subprocess import call

class LinuxRouter( Node ):

"A Node with IP forwarding enabled."
def __init__(self, name, **params):
self.nat = True
self.subnets = [ "192.168.101.0/24", "192.168.102.0/24" ]
super(LinuxRouter, self).__init__(name, **params)

def flush_nat(self):
self.cmd( 'sysctl -w net.ipv4.ip_forward=0' )
self.cmd( 'iptables -F' )

4
Ecole supérieure privée d’Ingénieurs de Monastir AU : 2021/2022

self.cmd( 'iptables -t nat -F' )

# Create default entries for unmatched traffic
self.cmd( 'iptables -P INPUT ACCEPT' )
self.cmd( 'iptables -P OUTPUT ACCEPT' )
self.cmd( 'iptables -P FORWARD ACCEPT' )

def config( self, **params ):

super( LinuxRouter, self).config( **params )
# Enable forwarding on the router
self.flush_nat()
self.cmd( 'sysctl -w net.ipv4.ip_forward=1' )
self.cmd('iptables -t nat -A POSTROUTING -j MASQUERADE')
self.cmd('ip addr flush r0-ethost1')
self.cmd('ip addr add 192.168.101.1/24 dev r0-ethost1')

def terminate( self ):

self.cmd( 'sysctl net.ipv4.ip_forward=0' )
super( LinuxRouter, self ).terminate()

class NetworkTopo( Topo ):

def build( self, **_opts ):

router = self.addNode( 'r0', cls=LinuxRouter )

s1, s2 = [ self.addSwitch( s ) for s in ( 's1', 's2') ]

self.addLink( s1, router, intfName2='r0-ethost1',

params2={ 'ip' : '192.168.101.1/24' } )
self.addLink( s2, router, intfName2='r0-ethost2',
params2={ 'ip' : '192.168.102.1/24' } )

host1 = self.addHost( 'host1', ip='192.168.101.100/24',

defaultRoute='via 192.168.101.1' )
host2 = self.addHost( 'host2', ip='192.168.102.100/24',
defaultRoute='via 192.168.102.1' )

for h, s in [ (host1, s1), (host2, s2) ]:

self.addLink( h, s )

if __name__ == '__main__':

lg.setLogLevel('info')
net = Mininet(topo=NetworkTopo(), controller=OVSController)
net.start()

for h in net.hosts:
h.cmd("mkdir -p /run/sshd")
h.cmd("/usr/sbin/sshd -D &")
info("\nssh daemons starting")

CLI(net)
for host in net.hosts:
host.cmd( 'kill /usr/sbin/sshd' )

5
Ecole supérieure privée d’Ingénieurs de Monastir AU : 2021/2022

net.stop

b- On remarque l’utilisation de deux classes principales, Node et Topo, issues du paquet

Mininet, qui permettent de définir des hosts et des topologies personnalisées en en
héritant.

sudo python mn.py

*** Creating network
*** Adding controller
*** Adding hosts:
host1 host2 r0
*** Adding switches:
s1 s2
*** Adding links:
(host1, s1) (host2, s2) (s1, r0) (s2, r0)
*** Configuring hosts
host1 host2 r0
*** Starting controller
c0
*** Starting 2 switches
s1 s2 ...

ssh daemons starting*** Starting CLI:

c- Vérifions que host1 passe bien par le routeur pour joindre host2 :

mininet> host1 mtr host2 -n --report -c 2

Start: 2018-04-07T17:29:08+0200
HOST: Loss% Snt Last Avg
Best Wrst StDev
1.|-- 192.168.101.1 0.0% 2 0.7 9.3
2.|-- 192.168.102.100 0.0% 2 0.8 14.8

d- Dans cet exemple, je m’assure également qu’un agent ssh écoute sur le port 22 pour
chaque host. Vérifions : (host1 ssh host2)

4- Conclusion
Mininet est très utilisé dans le cadre de développement SDN à base d’OpenFlow, puisqu’il
est possible de le piloter à partir d’un contrôleur externe. Dans la pratique, cet outil peut

6
Ecole supérieure privée d’Ingénieurs de Monastir AU : 2021/2022

être très utile dans le cadre d’applications plus classiques, puisqu’il permet de créer
automatiquement et par le code, des topologies personnalisées dans lesquelles on peut
induire des contraintes réseau diverses. Puisque toute l’infrastructure créée par Mininet
tourne sur une seule machine, il est simple de l’utiliser dans le cadre de tests applicatifs via
votre outil de CI préféré. C’est également un très bon outil pour mettre en place des
architectures de test ou de démonstration.