inlinetoc

Mininet crée un réseau virtuel réaliste, exécutant le code du noyau, du commutateur et de l'application, sur un seul ordinateur (VM, cloud ou natif), en quelques secondes, à l'aide d'une seule commande:

On peut facilement interagir avec le réseau à l'aide de la CLI (et de l'API) Mininet, le personnaliser, le partager avec d'autres personnes ou la déployer sur du matériel réel.

Mininet est également un excellent moyen de développer, de partager et d’expérimenter avec les systèmes OpenFlow et de réseau défini par logiciel.

Mininet est activement développé et supporté, et est publié sous une licence BSD Open Source.

Le moyen le plus simple de commencer est de télécharger une machine virtuelle Mininet / Ubuntu préemballée . Cette machine virtuelle inclut Mininet lui-même, tous les binaires et outils OpenFlow préinstallés, et peaufine la configuration du noyau pour prendre en charge les réseaux Mininet plus grands.

L’installation de VM est le moyen le plus simple et le plus sûr d’installer Mininet.

Suivez ces étapes pour une installation de machine virtuelle:

• Télécharger l' image de la VM Mininet .
• Télécharger et installer un système de virtualisation.

Cette option fonctionne bien pour une machine virtuelle locale, un EC2 distant et une installation native. Il suppose le point de départ d’une nouvelle installation Ubuntu (ou, à titre expérimental, Fedora).

Pour installer en mode natif depuis le source, cloner le code source:

git clone git://github.com/mininet/mininet 

Une fois l'arborescence source téléchargée, la commande pour installer Mininet est la suivante:

$ mininet/util/install.sh [options] 

Les options typiques install.sh incluent:

• -a: installer tout ce qui est inclus dans la machine virtuelle Mininet, y compris les dépendances telles que Open vSwitch, ainsi que les ajouts tels que le Wireshark et le POX. Par défaut, ces outils seront construits dans des répertoires créés dans votre répertoire personnel.
• -nfv : installe Mininet, le commutateur de référence OpenFlow et Open vSwitch
• -s mydir: utiliser cette option avant les autres pour placer les arborescences de génération dans un répertoire spécifié plutôt que dans le répertoire de base.

# Pour tout installer (en utilisant votre répertoire personnel)
$ install.sh -a
# Pour tout installer (en utilisant un autre répertoire pour la construction)
$ install.sh -s mydir -a
Pour installer Mininet + user switch + OVS (en utilisant le home dir)
$ install.sh -nfv
# Pour installer Mininet + user switch + OVS (en utilisant un autre dir)
$ install.sh -s mydir -nfv

Une fois l’installation terminée, tester la fonctionnalité de base de Mininet:

$ sudo mn --test pingall 

Avec une version récente d’Ubuntu, on peut installer les packages Mininet.

Ensuite, pour confirmer la version du système d'exploitation , exécuter la commande

$ lsb_release -a 

Ensuite, installer le paquet de base Mininet en utilisant la version correspondant à la distribution:

# Mininet 2.1.0 on Ubuntu 14.10: 
$ sudo apt-get install mininet 
# Mininet 2.1.0 on Ubuntu 14.04: 
$ sudo apt-get install mininet 
# Mininet 2.0.0 on Ubuntu 12.04: 
$ sudo apt-get install mininet/precise-backports 

Une fois cette opération terminée, désactiver openvswitch-controller s'il est installé et/ou en cours d'exécution:

$ sudo service openvswitch-controller stop 
$sudo update-rc.d openvswitch-controller disable 

Ensuite, tester Mininet:

$ sudo mn --test pingall 

Si Mininet se plaint qu'Open vSwitch ne fonctionne pas, il faudra peut-être reconstruire son module de noyau:

sudo dpkg-reconfigure openvswitch-datapath-dkms sudo 
service openflow-switch restart 

Syntaxe des commandes utilisées :

• $ précède les commandes Linux à taper à l’invite du shell
• mininet> précède les commandes Mininet qui doivent être tapées dans la CLI de Mininet,
• # précède les commandes Linux tapées à l’invite du shell root

Dans chaque cas, ne taper que la commande à droite de l'invite (puis appuyer sur return , bien sûr!)

Taper la commande suivante pour afficher un message d'aide décrivant les options de démarrage de Mininet:

$ sudo mn -h 

Cette procédure couvrira l'utilisation typique de la majorité des options répertoriées.

Pour commencer une topologie minimale et entrer la CLI:

$ sudo mn 

La topologie par défaut est la topologie minimal , qui comprend un commutateur de noyau OpenFlow connecté à deux hôtes, ainsi que le contrôleur de référence OpenFlow. Cette topologie peut également être spécifiée sur la ligne de commande avec --topo=minimal.

Les quatre entités (2 processus hôtes, 1 processus de commutation, 1 contrôleur de base) s'exécutent maintenant dans la machine virtuelle. Le contrôleur peut être en dehors de la machine virtuelle et les instructions correspondantes se trouvent en bas.

Si aucun test spécifique n'est passé en tant que paramètre, la CLI Mininet s'affiche.

Afficher les commandes CLI de Mininet:

mininet> help 

Noeuds d'affichage:

mininet> nodes 

Liens d'affichage:

mininet> net 

Dump des informations sur tous les nœuds:

mininet> dump 

On doit voir le commutateur et deux hôtes listés.

Si la première chaîne saisie dans la CLI Mininet est un nom d'hôte, de commutateur ou de contrôleur, la commande est exécutée sur ce noeud. Exécuter une commande sur un processus hôte:

mininet> h1 ifconfig -a 

On doit voir les interfaces h1-eth0 et loopback ( lo ) de l'hôte. Cette interface ( h1-eth0 ) n'est pas vue par le système Linux principal lors de l'exécution de ifconfig , car elle est spécifique à l'espace de noms réseau du processus hôte.

En revanche, le commutateur s'exécute par défaut dans l'espace de noms réseau racine. Par conséquent, exécuter une commande sur le «commutateur» revient à l'exécuter depuis un terminal standard:

mininet> s1 ifconfig -a 

Cela montrera les interfaces de commutateur, plus la sortie de connexion de la VM ( eth0 ).

Pour d'autres exemples soulignant que les hôtes ont un état de réseau isolé, exécuter arp et route sur s1 et h1 .

Il serait possible de placer chaque hôte, commutateur et contrôleur dans son propre espace de noms de réseau isolé, mais cela ne présente aucun avantage réel, sauf si vous souhaiter répliquer un réseau complexe à plusieurs contrôleurs. Mininet supporte cela; voir l'option –innamespace.

Il serait possible d'utiliser des espaces de processus distincts avec des conteneurs Linux, mais pour le moment, Mininet ne le fait pas. Avoir tout exécuté dans l'espace de noms de processus «racine» est pratique pour le débogage, car il vous permet de voir tous les processus à partir de la console en utilisant ps , kill , etc.

Maintenant, vérifier que l'on peut envoyer une requête ping de l’hôte 0 à l’hôte 1:

mininet> h1 ping -c 1 h2 

Si une chaîne apparaît plus tard dans la commande avec un nom de noeud, ce nom de noeud est remplacé par son adresse IP; cela s'est passé pour h2.

Le trafic de contrôle OpenFlow se décompose ainsi :

1. Le premier hôte emet une requète ARP pour l'adresse MAC du second, ce qui entraîne l'envoi d'un message packet_in au contrôleur.
2. Le contrôleur envoie ensuite un message packet_out pour inonder le paquet de diffusion à d'autres ports du commutateur (dans cet exemple, le seul autre port de données).
3. Le deuxième hôte voit la demande ARP et envoie une réponse.
4. Cette réponse est transmise au contrôleur, qui l'envoie au premier hôte et enfonce une entrée de flux.
5. Le premier hôte connaît maintenant l'adresse MAC du second et peut envoyer son ping via une requête d'écho ICMP.
6. Cette demande, ainsi que la réponse correspondante du deuxième hôte, vont toutes les deux au contrôleur et aboutissent à une entrée de flux enfoncée (avec les paquets réellement envoyés).

Répéter le dernier ping :

mininet> h1 ping -c 1 h2 

On doit voir un temps de ping beaucoup plus bas pour le deuxième essai (<100us). Une entrée de flux couvrant le trafic ping ICMP était précédemment installée dans le commutateur. Par conséquent, aucun trafic de contrôle n'a été généré et les paquets transitent immédiatement par le commutateur.

Un moyen plus facile d'exécuter ce test consiste à utiliser la commande pingall intégrée à la CLI de pingall , qui effectue un ping toutes les paires:

mininet> pingall 

Rappeler-vous que le ping n'est pas la seule commande que On peut exécuter sur un hôte! Les hôtes Mininet peuvent exécuter toute commande ou application disponible pour le système Linux sous-jacent (ou la machine virtuelle) et son système de fichiers. On peut également entrer n’importe quelle commande bash , y compris le contrôle des travaux ( & , jobs , kill , etc.)

Ensuite, essayer de démarrer un serveur HTTP simple sur h1 , en effectuant une requête à partir de h2 , puis en arrêtant le serveur Web:

mininet> h1 python -m SimpleHTTPServer 80 &
mininet> h2 wget -O - h1 
...
mininet> h1 kill %python 

Quitter la CLI:

mininet> exit 

Si Mininet se bloque pour une raison quelconque, il faut le nettoyer:

$ sudo mn -c 

Mininet peut également être utilisé pour exécuter des tests de régression autonomes.

Effectuer un test de régression:

$ sudo mn --test pingpair 

Cette commande créer une topologie minimale, démarre le contrôleur de référence OpenFlow, exécute ping test de paires, et supprime à la fois la topologie et le contrôleur.

iperf est un autre test utile (donner-lui environ 10 secondes):

$ sudo mn --test iperf 

Cette commande a créé le même Mininet, exécuté un serveur iperf sur un hôte, un client iperf sur le deuxième hôte et analysé la bande passante obtenue.

La topologie par défaut est un commutateur unique connecté à deux hôtes. On peut changer cela en un autre topo avec –topo , et transmettre des paramètres pour la création de cette topologie. Par exemple, pour vérifier la connectivité ping de toutes les paires avec un commutateur et trois hôtes:

Effectuer un test de régression:

$ sudo mn --test pingall --topo single,3 

Un autre exemple, avec une topologie linéaire (où chaque commutateur a un hôte et tous les commutateurs sont connectés en ligne):

$ sudo mn --test pingall --topo linear,4 

Les topologies paramétrées sont l’une des fonctionnalités les plus utiles et les plus puissantes de Mininet.

Mininet 2.0 permet de définir des paramètres de liaison, qui peuvent même être définis automatiquement à partir de la ligne de commande:

$ sudo mn --link tc,bw=10,delay=10ms mininet> iperf ... mininet> h1 ping -c10 h2

Si le délai pour chaque liaison est de 10 ms, le temps d'aller-retour (RTT) doit être d'environ 40 ms, car la demande ICMP traverse deux liaisons (une vers le commutateur, l'autre vers la destination) et la réponse ICMP traverse deux liaisons en retour. .

On peut personnaliser chaque lien à l'aide de l'API Python de Mininet , mais pour l'instant, vous souhaiterer probablement continuer avec la procédure pas à pas.

Le niveau de verbosité par défaut est info , qui imprime ce que fait Mininet lors du démarrage et du démontage. Comparer ceci avec la sortie de debug complète avec le -v :

$ sudo mn -v debug ...
mininet> exit 

Beaucoup de détails supplémentaires seront imprimés. Maintenant, essayer output , un paramètre qui imprime la sortie CLI et peu d’autres:

$ sudo mn -v output
mininet> exit 

En dehors de la CLI, d'autres niveaux de verbosité peuvent être utilisés, tels que warning , utilisé avec les tests de régression pour masquer les sorties de fonctions inutiles.

Les topologies personnalisées peuvent également être facilement définies à l'aide d'une simple API Python. Un exemple est fourni dans custom/topo-2sw-2host.py . Cet exemple connecte directement deux commutateurs, avec un seul hôte hors chaque commutateur: exemple de topologie simple (topo-2sw-2host.py) télécharger

"""Custom topology example

Two directly connected switches plus a host for each switch:

   host --- switch --- switch --- host

Adding the 'topos' dict with a key/value pair to generate our newly defined
topology enables one to pass in '--topo=mytopo' from the command line.
"""

from mininet.topo import Topo

class MyTopo( Topo ):
    "Simple topology example."

    def __init__( self ):
        "Create custom topo."

        # Initialize topology
        Topo.__init__( self )

        # Add hosts and switches
        leftHost = self.addHost( 'h1' )
        rightHost = self.addHost( 'h2' )
        leftSwitch = self.addSwitch( 's3' )
        rightSwitch = self.addSwitch( 's4' )

        # Add links
        self.addLink( leftHost, leftSwitch )
        self.addLink( leftSwitch, rightSwitch )
        self.addLink( rightSwitch, rightHost )


topos = { 'mytopo': ( lambda: MyTopo() ) }

Lorsqu'un fichier mininet personnalisé est fourni, il peut ajouter de nouvelles topologies, types de commutateur et tests à la ligne de commande. Par exemple:

$ sudo mn --custom ~/mininet/custom/topo-2sw-2host.py --topo mytopo --test pingall 

Par défaut, les hôtes commencent par des adresses MAC attribuées de manière aléatoire. Cela peut rendre le débogage difficile, car chaque fois que le Mininet est créé, les MAC changent. Il est donc difficile de corréler le trafic de contrôle avec des hôtes spécifiques.

L'option –mac est –mac utile et définit les adresses MAC et IP de l'hôte sur de petits ID uniques et faciles à lire.

Avant:

$ sudo mn
...
mininet> h1 ifconfig
h1-eth0  Link encap:Ethernet  HWaddr f6:9d:5a:7f:41:42  
          inet addr:10.0.0.1  Bcast:10.255.255.255  Mask:255.0.0.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:6 errors:0 dropped:0 overruns:0 frame:0
          TX packets:6 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:392 (392.0 B)  TX bytes:392 (392.0 B)
mininet> exit

Après:

$ sudo mn --mac
...
h1-eth0  Link encap:Ethernet  HWaddr 00:00:00:00:00:01
          inet addr:10.0.0.1  Bcast:10.255.255.255  Mask:255.0.0.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)
mininet> exit

En revanche, les adresses MAC des ports de données de commutateur déclarées par Linux resteront aléatoires. En effet, On peut “affecter” un MAC à un port de données à l'aide d'OpenFlow, comme indiqué dans la FAQ. C'est un point quelque peu subtil que On peut probablement ignorer pour le moment.

Pour un débogage plus complexe, On peut démarrer Mininet afin qu’il génère un ou plusieurs xterms.

Pour démarrer un xterm pour chaque hôte et commutateur, passer l'option -x :

$ sudo mn -x 

Après une seconde, les xterms apparaîtront, avec les noms de fenêtre définis automatiquement.

Alternativement, On peut faire apparaître xterms supplémentaires comme indiqué ci-dessous.

Par défaut, seuls les hôtes sont placés dans un espace de noms séparé. la fenêtre de chaque commutateur n'est pas nécessaire (c'est-à-dire équivalente à un terminal classique), mais peut être un endroit pratique pour exécuter et laisser en place des commandes de débogage de commutateur, telles que des vidages de compteurs de flux.

Les Xterms sont également utiles pour exécuter des commandes interactives que vous devrer peut-être annuler, pour lesquelles vous voudrier voir le résultat.

Par exemple:

Dans le xterm intitulé “switch: s1 (root)”, exécuter:

# dpctl dump-flows tcp:127.0.0.1:6634 

Rien ne sera imprimé; le commutateur n'a aucun flux ajouté. Pour utiliser dpctl avec d'autres commutateurs, démarrer mininet en mode commenté et examiner les ports d'écoute passifs des commutateurs lors de leur création.

Maintenant, dans le xterm intitulé “host: h1”, exécuter:

# ping 10.0.0.2 

Retourner à s1 et vider les flux: # dpctl dump-flows tcp: 127.0.0.1: 6634

On doit voir plusieurs entrées de flux maintenant. Alternativement (et généralement plus pratique), On peut utiliser la commande dpctl intégrée à la CLI de Mininet sans avoir besoin de xterms ou en spécifiant manuellement l’adresse IP et le port du commutateur.

On peut savoir si un xterm se trouve dans l'espace de noms racine en vérifiant ifconfig; si toutes les interfaces sont affichées (y compris eth0 ), c'est dans l'espace de noms racine. De plus, son titre doit contenir «(racine)».

Fermer la configuration, à partir de la CLI Mininet:

mininet> exit 

Les xterms devraient se fermer automatiquement.

D'autres types d'interrupteurs peuvent être utilisés. Par exemple, pour exécuter le commutateur d'espace utilisateur:

$ sudo mn --switch user --test iperf 

Un autre exemple de type de commutateur est Open vSwitch (OVS), préinstallé sur la VM Mininet. La bande passante TCP rapportée par iperf devrait être similaire au module de noyau OpenFlow, et peut-être plus rapide:

$ sudo mn --switch ovsk --test iperf 

Pour enregistrer le temps nécessaire à la configuration et au démantèlement d’une topologie, utiliser le test 'aucun':

$ sudo mn --test none 

Par défaut, les hôtes sont placés dans leur propre espace de noms, tandis que les commutateurs et le contrôleur se trouvent dans l'espace de noms racine. Pour placer les commutateurs dans leur propre espace de noms, passer l'option –innamespace :

$ sudo mn --innamespace --switch user 

Au lieu d'utiliser le bouclage, les commutateurs communiquent avec le contrôleur via une connexion de contrôle pontée séparément. En soi, cette option n’est pas très utile, mais elle fournit un exemple montrant comment isoler différents commutateurs.

mininet> exit 

Pour afficher la liste des options de l'interface de ligne de commande, démarrer une topologie minimale et laisser-la en cours d'exécution. Construiser la mininet:

$ sudo mn 

Afficher les options:

mininet> help 

Si la première phrase de la ligne de commande de Mininiet est py , cette commande est exécutée avec Python. Cela pourrait être utile pour étendre Mininet, ainsi que pour sonder son fonctionnement interne. Chaque hôte, commutateur et contrôleur a un objet Node associé.

Sur la CLI Mininet, exécuter:

mininet> py 'hello ' + 'world' 

Imprimer les variables locales accessibles:

mininet> py locals() 

Ensuite, voir les méthodes et propriétés disponibles pour un nœud, à l'aide de la fonction dir ():

mininet> py dir(s1) 

On peut lire la documentation en ligne pour les méthodes disponibles sur un nœud en utilisant la fonction help ():

mininet> py help(h1) (Press "q" to quit reading the documentation.) 

On peut également évaluer les méthodes de variables:

mininet> py h1.IP() 

Pour le test de tolérance aux pannes, il peut être utile d’élever et de réduire les liens.

Pour désactiver les deux moitiés d'une paire Ethernet virtuelle:

mininet> link s1 h1 down 

Une notification de changement d'état du port OpenFlow devrait être générée. Pour rétablir le lien:

mininet> link s1 h1 up 

Pour afficher un xterm pour h1 et h2:

mininet> xterm h1 h2 

Le répertoire des exemples dans l'arborescence des sources de Mininet contient des exemples sur l'utilisation de l'API Python de Mininet, ainsi que du code potentiellement utile qui n'a pas été intégré à la base de code principale.

Un exemple particulièrement utile exécute un démon SSH sur chaque hôte:

$ sudo ~/mininet/examples/sshd.py 

Depuis un autre terminal, On peut ssh dans n’importe quel hôte et exécuter des commandes interactives:

$ ssh 10.0.0.1```
$ ping 10.0.0.2 ...```
$ exit 

Quitter SSH exemple mininet:

$ exit 

Celles-ci ne sont pas obligatoires, mais peuvent être utiles.

C'est particulièrement utile lorsqu'on a un contrôleur fonctionnant en dehors de la VM, par exemple sur l'hôte de la VM, ou un autre PC physique.

Lorsqu'on démarrer un réseau Mininet, chaque commutateur peut être connecté à un contrôleur distant, qui peut se trouver dans la VM, en dehors de la VM et sur une machine locale ou ailleurs dans le monde.

Cette configuration peut être pratique lorsqu'on a déjà une version personnalisée d'un framework de contrôleur et des outils de développement (tels qu'Eclipse) installés sur la machine locale, ou lorsqu'on souhaite tester un contrôleur s'exécutant sur une machine physique différente (peut-être même dans le cloud). .

Utiliser controller --remote pour démarrer un commutateur et renseigner l'adresse IP de l'hôte et/ ou le port d'écoute:

$ sudo mn --controller=remote,ip=[controller IP],port=[controller listening port] 

Par exemple, pour exécuter un exemple de commutateur d’apprentissage de POX, On peut effectuer les opérations suivantes:

$ cd ~/pox
$ ./pox.py forwarding.l2_learning 

Dans une fenêtre, et dans une autre fenêtre, démarrer Mininet pour vous connecter au contrôleur «distant» (qui s'exécute réellement localement, mais en dehors du contrôle de Mininet):

$ sudo mn --controller=remote,ip=127.0.0.1,port=6633 

Si vous générer du trafic (par exemple, h1 ping h2 ), On doit pouvoir observer une sortie dans la fenêtre POX indiquant que le commutateur est connecté et que certaines entrées de la table de flux ont été installées.

Un certain nombre de structures de contrôleur OpenFlow sont facilement disponibles et devraient fonctionner facilement avec Mininet, à condition de les démarrer et de spécifier l'option de contrôleur remote avec l'adresse IP correcte de la machine sur laquelle votre contrôleur s'exécute et le port correct sur lequel il est à l'écoute.

L’installation par défaut de Mininet (avec util/install.sh -a ) n’installe pas NOX Classic. Pour l'installer, lancer sudo ~/mininet/util/install.sh -x.

Pour exécuter un test de régression avec NOX exécutant le pyswitch application NOX, NOX_CORE_DIR doit être définie sur le répertoire contenant l'exécutable NOX.

Commencer par vérifier que NOX s'exécute:

$ cd $NOX_CORE_DIR
$ ./nox_core -v -i ptcp: 

Ctrl-C pour tuer NOX, puis lancer un test avec NOX pyswitch:

$ cd
$ sudo -E mn --controller=nox,pyswitch --test pingpair 

Il y a une hésitation de quelques secondes pendant que NOX charge et le commutateur se connecte, mais alors il devrait terminer le ping .

Cette fois-ci, mn a été appelé via sudo -E pour conserver la variable d’environnement NOX_CORE_DIR . Si on exécute nox à distance en utilisant --controller remote\ , --controller remote -E n'est pas nécessaire. Alternativement, On peut changer la première ligne de /etc/sudoers , via sudo visudo , pour changer la ligne env_reset en:

Defaults !env_reset 

… Afin que, lors de l'exécution de sudo la configuration de env var ne soit pas modifiée.