# MININET: Overview {{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. # Installation de Mininet 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. ## Option 1: Installation de Mininet VM (facile, recommandé) 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. ## Option 2: Installation native à partir de la source 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 ``` La commande git ci-dessus va extraire la dernière et la plus grande des versions de Mininet. Pour utiliser la dernière version stable publiée de Mininet - ou toute autre version - indiquer cette version de manière explicite:\\ \\ `cd mininet`\\ `git tag # list available versions`\\ `git checkout -b 2.2.1 # 2.2.1 or whatever version you wish to install`\\ `cd .. ` 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 ``` ## Option 3: Installation à partir de packages Avec une version récente d’Ubuntu, on peut installer les packages `Mininet`. Pour effectuer une mise à niveau à partir d’une installation antérieure de Mininet (telle que 1.0) ou d’une version de Open vSwitch compilée et stockée dans `/usr/local` , il faut supprimer toute trace de versions antérieures de Mininet :\\ `$ sudo rm -rf /usr/local/bin/mn /usr/local/bin/mnexec /usr/local/lib/python*/*/*mininet* /usr/local/bin/ovs-* /usr/local/sbin/ovs-* ` 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 ``` Pour installer les logiciels supplémentaires (le commutateur de référence OpenFlow, le contrôleur de référence et le dissecteur Wireshark), utiliser les commandes suivantes:\\ \\ `git clone git://github.com/mininet/mininet`\\ `mininet/util/install.sh -fw` # Utilisation quotidienne de Mininet 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!) ## Afficher les options de démarrage 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. ## Interagir avec les hôtes et les commutateurs 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**. Seul le réseau est virtualisé. chaque processus hôte voit le même ensemble de processus et de répertoires. Par exemple, imprimer la liste des processus à partir d’un processus hôte:\\ \\ `mininet> h1 ps -a `\\ \\ Cela devrait être exactement le même que celui vu par l'espace de noms du réseau racine:\\ \\ `mininet> s1 ps -a` 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. ## Tester la connectivité entre les hôtes 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 : - 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. - 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). - Le deuxième hôte voit la demande ARP et envoie une réponse. - Cette réponse est transmise au contrôleur, qui l'envoie au premier hôte et enfonce une entrée de flux. - Le premier hôte connaît maintenant l'adresse MAC du second et peut envoyer son ping via une requête d'écho ICMP. - 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 ``` ## Exécuter un serveur Web simple et un client 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 ``` ## Nettoyer Si Mininet se bloque pour une raison quelconque, il faut le nettoyer: ``` $ sudo mn -c ``` # Options de démarrage avancées ## Exécuter un test de régression 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. ## Changement de taille et du type de topologie 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. ## Variations de lien 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. ## Réglage de la verbosité 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. ## Topologies personnalisées 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 ``` ## ID = MAC 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. ## Affichage XTerm 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. ## Autres types de commutateur 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 ``` La bande passante rapportée par iperf TCP est beaucoup plus basse par rapport à celle vue précédemment avec le commutateur de noyau.\\ \\ Pour le test ping présenté ci-dessus, on remarquera un délai beaucoup plus long, car les paquets doivent désormais supporter des transitions supplémentaires noyau à espace utilisateur. Le temps de ping sera plus variable, car le processus d’espace utilisateur représentant l’hôte peut être programmé en entrée et en sortie par le système d’exploitation.\\ \\ D'autre part, le commutateur d'espace utilisateur peut constituer un bon point de départ pour la mise en œuvre de nouvelles fonctionnalités, en particulier lorsque les performances logicielles ne sont pas critiques. 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 ``` ## Benchmark Mininet Pour enregistrer le temps nécessaire à la configuration et au démantèlement d’une topologie, utiliser le test 'aucun': ``` $ sudo mn --test none ``` ## Tout dans son propre espace de noms (commutateur utilisateur uniquement) 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. Cette option ne fonctionne pas (à compter du 19/11/12) avec Open vSwitch. ``` mininet> exit ``` # Commandes de l'interface de ligne de commande (CLI) de Mininet ## Option d'affichage 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 ``` ## Interprète python 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() ``` ## Link Up/Down 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 ``` ## Affichage XTerm Pour afficher un xterm pour h1 et h2: ``` mininet> xterm h1 h2 ``` # Exemples d'API Python 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. Comme indiqué au début, cette procédure suppose l'utilisation d'une VM Mininet, qui contient tout ce dont on a besoin, ou une installation native avec tous les outils associés, y compris le contrôleur de controller référence, qui fait partie de la référence OpenFlow. d’implémentation et peut être installé avec `install.sh -f` s’il n’a pas été installé. ## Démon SSH par hôte 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 ``` # Informations supplémentaires Celles-ci ne sont pas obligatoires, mais peuvent être utiles. ## Utiliser un Remote Controller 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 ``` Iil s'agit en fait des valeurs d'adresse IP et de port par défaut. 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. ## NOX Classic 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`. NOX Classic est obsolète et pourrait ne plus être pris en charge ultérieurement. 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 ``` L'option `--controller` a une syntaxe pratique pour spécifier des options pour le type de contrôleur (dans ce cas, nox exécute pyswitch .) 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.