Embed Size (px)
Citation preview
Scuola Politecnica e delle Scienze di Base Corso di Laurea in Ingegneria Informatica Elaborato finale in Reti Di Calcolatori
L’emulatore di Reti Mininet
Anno Accademico 2015/2016 Candidato: Alessio Madonia matr. N46/000094
A tutte le persone a me care, che mi hanno affiancato in questo percorso di vita…
Indice
Indice .................................................................................................................................................. III Introduzione ......................................................................................................................................... 4 Capitolo 1: Differenze tra Simulatore ed Emulatore ........................................................................... 5
1.1 Simulazione ................................................................................................................................ 5
1.2 Emulazione................................................................................................................................. 5 1.3 Emulazione nelle Reti ................................................................................................................ 5
Capitolo 2 OpenFlow ........................................................................................................................... 7 2.1 Funzionamento OpenFlow ......................................................................................................... 7
Capitolo 3: Mininet .............................................................................................................................. 9 3.1 L’emulatore Mininet .................................................................................................................. 9
3.1.1 Vantaggi Mininet ......................................................................................................... 10
3.1.2 Svantaggi Mininet ........................................................................................................ 10 3.2 Installazione Mininet ........................................................................................................... 11 3.3 Creazione Topologia di Rete ............................................................................................... 12 3.4 Interazione con la rete ......................................................................................................... 15
Capitolo 4: MiniEdit .......................................................................................................................... 19 4.1 Avvio di MiniEdit .................................................................................................................... 19
4.2 Interfaccia MiniEdit ................................................................................................................. 20 4.2.1 Configurazione Controller ........................................................................................... 22 4.2.2 Preferenze ..................................................................................................................... 22
4.2.3 Salvataggio Preferenze ................................................................................................. 23 4.2.4 Salvataggio Configurazione ......................................................................................... 23
4.2.5 Esecuzione scenario di rete .......................................................................................... 23
4.2.6 Configurazione switch virtuale .................................................................................... 24
Capitolo 5: Interazione con Wireshark .............................................................................................. 25 5.1 Avvio Wireshark ...................................................................................................................... 26 5.2 Configurazione Wireshark / Mininet ....................................................................................... 27
Conclusioni ........................................................................................................................................ 29 Bibliografia ........................................................................................................................................ 30
4
Introduzione
Le reti di telecomunicazione con il passare degli anni, si sono evolute rapidamente, esse
sono diventate uno strumento essenziale per la comunicazione.
Inizialmente le funzionalità di rete erano dedicate negli apparecchi, come router e switch
con hardware opportuno atto a risolvere specifiche applicazioni di calcolo.
Questo tipo di approccio è complicato poiché essi dovevano essere configurati
manualmente, così le operazioni diventavano onerose per il tempo impiegato. Alcuni
dispositivi, essendo proprietari, non avevano il diritto di modifica, quindi si era costretti a
contattare il produttore.
Le attuali applicazioni informatiche richiedono che le reti di telecomunicazioni siano
sempre più dinamiche, ovvero che siano in grado di adattarsi alle singole esigenze degli
utenti.
Utilizzando un emulatore Mininet, è possibile emulare reti anche complesse su dispositivi
semplici, come Notebook e PC Desktop.
Tramite software è possibile testare la flessibilità e la programmabilità delle reti.
Noi ci occuperemo di capire la differenza tra emulatore e simulatore ed espliciteremo
l’installazione e il funzionamento dell’emulatore Mininet, avendo la possibilità di creare
reti virtuali, sul terminale o attraverso file con script in linguaggio Python.
Inoltre, faremo vedere come è possibile creare in automatico gli script in Python con
l’ausilio di un’estensione di Mininet, ovvero MiniEdit.
5
Capitolo 1: Differenze tra Simulatore ed Emulatore
In questo capitolo spiegheremo le differenze tra emulazione e simulazione.
1.1 Simulazione
La simulazione è un modello del sistema reale, essa ci fornisce indicazioni sul
comportamento del nostro sistema con prefissati parametri iniziali.
Esempi: simulatori di volo, previsioni del tempo, simulatore di reti.
1.2 Emulazione
L'emulazione duplica le funzioni su un sistema "Guest", usandone un altro differente
"Host", in modo che quest'ultimo si comporti a tutti gli effetti come se fosse il primo
sistema.
Un emulatore può essere hardware o software.
esempi: emulatori per console, emulatori di reti.
1.3 Emulazione nelle Reti
Nel nostro caso ci interessa specificare un emulatore di rete.
Essi consentono di riprodurre il funzionamento di una rete su uno o più calcolatori
mediante la virtualizzazione.
La virtualizzazione consiste in un insieme di tecniche hardware, software o ibride che
consentono di realizzare una risorsa virtuale identica per funzionalità ad una reale,
suddividendo quest’ultima in diversi ambienti operativi isolati dalla macchina fisica
sottostante.
Gli apparati di rete virtuali associano un processo ad ogni apparato di rete.
6
I processi si scambiano messaggi ed informazioni utilizzando i protocolli come se fossero
apparati di rete connessi tramite una rete reale.
Molto spesso la rete emulata può essere connessa a segmenti di una rete reale utilizzando
interfacce di rete dei calcolatori coinvolti nell'emulazione.
SCOPO:
- Collaudare funzioni e protocolli.
- Estendere le dimensioni o l'estensione della rete reale.
- Effettuare misure in condizioni di traffico controllate.
- Studiare gli effetti di eventi che nella realtà avverrebbero raramente.
7
Capitolo 2 OpenFlow
OpenFlow è un protocollo di rete utilizzato per gestire il traffico tra gli elementi di rete.
Esso realizza un SND ( Software Defined Networking), ovvero un approccio di rete in cui
il controllo è disaccoppiato dall’hardware e gestito da un software chiamato controller,
rendendo le reti programmabili.
OpenFlow, si basa sugli switch Ethernet con le Flow Table ed un’interfaccia per
aggiungere o rimuovere le Flow Entries che costituiscono le tabelle di flusso interno.
L’idea delle OpenFlow è quella di rendere possibile la gestione di più reti attraverso il
collegamento al controller, il quale semplifica la gestione dei flussi e quindi permette in
maniera semplificata e più efficiente la gestione dell’intera infrastruttura, la definizione
delle politiche e la gestione del tipo di traffico.
2.1 Funzionamento OpenFlow
Alla base dell’OpenFlow c’è la separazione del software di controllo del traffico dai router
e dagli switch reali attraverso cui passano i pacchetti di dati.
OpenFlow è formato in tre parti :
Tabelle di flusso installate negli switch.
Controller.
Un protocollo che il controller usa per comandare gli switch.
8
Il Controller opera sugli switch secondo le regole contenute nelle tabelle di flusso, che
installa in base al comportamento richiesto.
Le regole che sono nelle Flow Table, si chiamano Flow Entries.
Fig. 1 Schema OpenFlow
Uno switch OpenFlow a differenza di quello classico, è composto dal solo data path,
mentre le decisioni di routing di alto livello sono spostate al controller.
Il data path di uno switch OpenFlow è costituito dalla Flow Table, all’interno della quale
a ogni sua voce è associata una particolare azione prevista.
Lo switch OpenFlow e il controller comunicano tramite protocollo OpenFlow.
9
Capitolo 3: Mininet
Nel terzo capitolo introduciamo l’emulatore Mininet, i requisiti di sistema, l’installazione
di esso ed alcuni comandi per la realizzazione di una rete virtuale.
3.1 L’emulatore Mininet
Per testare le reti usiamo l’emulatore Mininet.
I test effettuati sono abbastanza validi, in quanto è possibile ottenere dati simili alla realtà
con tutti i pro e i contro che ne conseguono.
Questo software di emulazione è stato sviluppato con lo scopo di poter eseguire test estesi
utilizzando anche risorse limitate come Notebook e PC-Desktop.
Mininet gestisce un insieme di terminali di rete (host), switch, router e i vari collegamenti
su un unico ambiente Linux.
Linux è in grado di simulare un’intera rete con una virtualizzazione leggera, consentendo
nell’ambito dell’esecuzione di un singolo sistema operativo, l’avvio di interfacce virtuali
connesse da cavi virtuali.
In questo modo si può ottenere un miglioramento sia nello spreco di memoria che nel
tempo di realizzazione ed avvio degli esperimenti, riuscendo a realizzare test anche con
topologie molto complesse.
Il trasferimento sui nodi reali può avvenire in maniera quasi del tutto automatica,
permettendo una prototipazione rapida alle reti di calcolatori.
10
3.1.1 Vantaggi Mininet
Velocità : l’avvio di una semplice rete richiede pochi secondi.
Creazione di topologie personalizzate : singolo o multi switch.
Possibilità di eseguire programmi reali : programmi su linux possono essere eseguiti
su switch e host creati.
Personalizzazione ed inoltro di pacchetti: gli switch di Mininet sono programmabili,
usando un apposito protocollo Openflow, le funzionalità testate su di essi possono
essere trasferite anche su switch reali.
Portabilità Mininet : può essere eseguito su macchine Linux oppure su una Virtual
Machine. (MININET è stato introdotto dalla versione 12.10 in su di Ubuntu).
Condivisione e replica del codice : una volta copiato il codice è possibile eseguirlo
senza riscontrare problemi.
Facilità di utilizzo : creare esperimenti semplici o più complessi con script in Python.
Codice Open Source : si può esaminare e modificare il codice sorgente di Mininet al
seguente indirizzo https://github.com/mininet
Crescita continua di Mininet: è possibile interagire con gli sviluppatori per
aggiornare il software.
3.1.2 Svantaggi Mininet
Limitazioni nell’eseguire una rete su un unico sistema : le risorse dovranno essere
bilanciate tra gli host.
Mininet utilizza un unico kernel Linux per tutti gli host virtuali : non è possibile
eseguire software dipendente da kernel differenti.
Mininet non crea il controller, se si necessita di uno personalizzato, bisognerà
implementarlo.
Per impostazione predefinita la rete Mininet è isolata dalla LAN e da internet, questo
perchè ci evita eventuali inconvenienti dovuti alla rete. Nonostante sia isolata dalla
rete esterna è possibile connetterla ad essa in più modi.
Per impostazione predefinita, tutti gli host Mininet condividono il file host del
11
sistema e lo spazio PID. Bisogna prestare particolare attenzione quando si eseguono
i programmi a non far terminare i processi necessari.
A differenza di un simulatore, Mininet non ha una nozione forte del tempo virtuale,
ciò significa che le misure temporali saranno basate sul tempo reale e quindi,
emularle con maggiore velocità non sarà semplice.
3.2 Installazione Mininet
Il modo più rapido per l’installazione di Mininet è quello di usare una Virtual Machine e
tramite essa lanciare il software in questione messo a disposizione al seguente link
http://mininet.org/download/ .
Si tratta di un pacchetto contenente un’installazione di Ubuntu Linux 14.04 con Mininet
preinstallato ed alcune modifiche al kernel per poter supportare anche le reti più
complesse.
Una volta scaricato il pacchetto è sufficiente aprirlo con la Virtual Machine.
Successivamente al login, l’interfaccia presentata sarà la seguente:
Fig. 2 Login Mininet
è un’interfaccia a linea di comando con la quale è possibile interagire con essa.
12
Abbiamo a disposizione altre tipologie di istallazione, ad esempio:
Installazione del software nativo, tramite repository. Questa opzione è ottimale per Virtual
Machine locali, in quanto è possibile poi apportarne i relativi aggiornamenti.
Per recuperare il codice sorgente, basta digitare sul terminale:
E successivamente si prosegue all’installazione con il comando:
Se si dispone di una recente versione di Ubuntu, è possibile avviare il sistema operativo
con già installata una versione di Mininet. Questo approccio non è ottimale, poiché è
possibile che non venga installata l’ultima versione del software, ma per un primo
approccio può andar bene.
3.3 Creazione Topologia di Rete
Una volta eseguita l’installazione della Virtual Machine e di Mininet, è possibile creare
una rete utilizzando un singolo comando digitandolo sul terminale, un esempio:
$ sudo mn - -topo single,3 - - mac - -switch ovsk - -controller remote
Fig. 3 Esempio topologia Mininet
13
Fig. 4 Schema Topologia
Andiamo ad esplicitare questa linea di codice:
sudo è l’istruzione che ci abilita i permessi di amministratore su Linux.
mn è l’istruzione che viene chiesta a Mininet per creare la topologia desiderata.
- - topo single,3 crea la topologia di rete, uno switch e tre host collegati ad esso.
- - mac si chiede che ad ogni interfaccia venga assegnato un indirizzo MAC equivalente
all’indirizzo IP.
- - switch permette di scegliere quale tipo di implementazione di switch debba essere
utilizzata per l’emulazione.
- - controller si chiede che gli switch si connettano al controller specificato.
remote senza specificare un indirizzo IP, gli switch si connetteranno all’indirizzo
127.0.0.1 di loopback (viene utilizzata nelle reti TCP/IP per identificare la macchina locale
su cui i programmi sono in esecuzione, chiamato localhost) con porte TCP: 6633.
La topologia più semplice da implementare utilizza la linea di comando:
$ sudo mn
14
Esso creerà una topologia con 2 host, 1 switch ed 1 controller.
Fig. 5 Esempio Topologia Mininet
Per testare la connettività tra gli host, possiamo digitare sul terminale :
mininet> h1 ping –c 3 h2
Fig. 6 Ping tra Host
Questo comando verifica la raggiungibilità o meno dell’host h2 partendo da h1.
L’host sorgente h1 invia in broadcast (ARP Request) contenente l’indirizzo IP del
nodo destinazione h2. Questo causa l’invio di un messaggio di tipo Packet_In per il
controller.
Il controller invia un messaggio di tipo Packet_Out allo switch.
L’host h2 vede l’ARP Request ed invia un ARP Reply broadcast in risposta.
15
La risposta giunge al controller che rimanda la Reply all’ host h1 installando nello
switch una Flow_Entry.
Quindi l’host h1 conosce l’indirizzo IP dell’host h2 e può inviare i sui ping attraverso
il protocollo ICMP.
Sia la richiesta che la risposta dell’ICMP vengono processate dal controller e verrà
installato un nuovo flusso sempre nella Flow_ Table.
Osservando l’output di questo comando, il tempo del primo ping è nettamente superiore a
quello degli altri. Questo avviene perchè il primo ha aspettato che si installassero nello
switch le regole per gestire questo tipo di azioni.
Un altro metodo per creare topologie di rete con il nostro emulatore è quello di usare degli
script in codice Python, utilizzando apposite API per Miminet.
L’elenco completo delle API Mininet si può trovare al seguente indirizzo:
http://mininet.org/api.
Utilizzando gli script si possono creare e salvare topologie per poterle riutilizzare in
seguito, in modo più rapido.
3.4 Interazione con la rete
Creata la topologia desiderata, sarà possibile interagire con Mininet attraverso linee di
comando CLI (Command Line Interface). Vediamo alcuni esempi :
nodes : visualizza i nodi creati, nel nostro caso abbiamo 3host, 1 switch ed 1 controller
Fig.7 Nodi Creati
16
net : ci mostra i nodi e le connessioni associate alle relative porte.
Fig. 8 Nodi e connessioni relative
h1 ifconfig : Vengono visualizzate le interfacce del nodo di nostro interesse, nel nostro
caso l’host h1.
Fig. 9 Interfacce del nodo d’interesse
17
Per poter visualizzare tutti i comandi utilizzabili allora scriveremo nel terminale, help :
Fig. 10 Comando help
pingall : si eseguono dei ping tra tutti gli host connessi alla rete :
Fig. 11 Comando help
18
Definiamo altri comandi :
dump : stampa a video le informazioni relative a tutti i nodi creati.
iperf : esegue un test di banda tra 2 host della rete.
exit : è possibile uscire dalla rete e tornare all’interfaccia di linux.
xterm : è possibile avviare terminali relativi ai vari nodi.
19
Capitolo 4: MiniEdit
Nel quarto capitolo introduciamo MiniEdit, un tool creato per dimostrare come è possibile
estendere Mininet.
Mostreremo come usare questo tool per creare e lanciare un’emulazione di rete, quindi
andremo a configurare graficamente i vari elementi della rete per poi salvarne la topologia
e lanciare l’emulazione attraverso Mininet.
4.1 Avvio di MiniEdit
Avviare MiniEdit è molto semplice, in quanto esso è già presente in Mininet, quindi basta
digitare sul terminale il seguente comando :
Possiamo notare che per lanciare MiniEdit è necessario avviarlo con i permessi di
amministratore.
20
4.2 Interfaccia MiniEdit
L’interfaccia di MiniEdit è molto semplice, in quanto presenta sul lato sinistro della
finestra, le varie icone per poter creare la nostra topologia personalizzata ed una barra di
menù posizionata verso l’alto.
Fig. 12 Interfaccia MiniEdit
In questa finestra, possiamo notare che ci sono differenti pulsanti con cui interagire.
Andiamo ad illustrarli :
Select tool : è usato per muovere i nodi sulla nostra schermata in modo molto semplice
con un semplice click and drag. Una volta attivato il pulsante Select, appena il puntatore è
al di sopra di un collegamento o di un nodo ci da le diverse opzioni per interagire con esso.
21
Host tool : crea i nodi sulla schermata che eseguiranno le funzioni degli host. Basterà
selezionare il pulsante Host e poi cliccare sulla schermata per posizionare uno o più nodi.
Switch tool : permette di creare degli switch sulla nostra schermata, questi switch sono
previsti per poi avere un collegamento con un controller. Come l’host tool, anche lo switch
tool basta cliccare prima sul pulsante e poi sulla schermata interessata per posizionare uno
o più switch.
Legacy Switch tool: esso crea un particolare tipo di switch con impostazioni di default.
Esso non è configurabile, opera indipendentemente, ovvero senza un controllore.
The Legacy Router tool : crea un router basilare che opererà indipendentemente, senza
un controller. Esso è composto da 1 host con IP forwarding e non può essere configurato
dal MiniEdit GUI.
NetLink tool : crea il collegamento tra i vari nodi nella schermata, basta cliccare il
pulsante NetLink e selezionare il nodo interessato trascinando il cursone fino al nodo di
destinazione.
Controller tool : esso crea uno o più controller. Le impostazioni di default implementano
un learning switch, ovvero un OpenFlow controller, anche se possono essere configurati
altri tipi di controller.
Run botton: simula lo scenario appena configurato nella finestra di MiniEdit.
Stop botton: Termina lo stato di esecuzione dello scenario appena avviato.
22
4.2.1 Configurazione Controller
Di default Mininet usa un controllore OpenFlow, esso è un protocollo di comunicazione
che consente l’accesso al piano di inoltro di un dispositivo di rete (switch, router),
attraverso la rete. Abbiamo bisogno di configurare ciascun controller in modo che venga
utilizzata una porta diversa.
Fig. 13 Configurazione Controller
4.2.2 Preferenze
Per impostare le preferenze di MiniEdit, è necessario andare nella barra dei menù, sotto la
voce modifica
Fig. 14 Impostazioni
23
Per impostazione predefinita, MiniEdit non permette l’accesso alla riga di comando di
Mininet. Se si vuole essere in grado di utilizzare il Mininet CLI, quando una simulazione è
in esecuzione, bisogna selezionare l’apposita casella start CLI.
4.2.3 Salvataggio Preferenze
Le preferenze di MiniEdit vengono salvate nel file della topologia dello scenario creato. In
questo modo si può avere preferenze diverse per ogni scenario memorizzato.
4.2.4 Salvataggio Configurazione
Avendo definito uno scenario di rete, che dovrebbe consentire ad ogni host di comunicare
con qualsiasi altro host, allora possiamo salvare il file della topologia di MiniEdit in modo
da poter caricare questo scenario in futuro.
Un’altra possibile scelta è quello di esportare uno script in Python, in modo da poterlo
lanciare in una finestra di terminale.
Per salvare il file della topologia di Mininet (*.MN), basta cliccare su "File" nella barra dei
menù e selezionare "salva".
Per salvare il file in Pyhton (*.py), bisogna cliccare su "File" nella barra dei menù e
selezionare "salva livello 2 script".
4.2.5 Esecuzione scenario di rete
Per avviare lo scenario di simulazione, basta fare click sul pulsante "Run" sulla GUI di
MinEdit. Nella finestra di terminale da cui è stato avviato MiniEdit, vedremo alcuni
messaggi che mostrano l’avanzamento della messa in simulazione e poi il prompt
MiniEdit CLI ( impostato precedentemente) . Prima di uscire e chiudere la finestra,
assicurarsi che abbia finito tutta la procedura.
24
4.2.6 Configurazione switch virtuale
Verifichiamo le configurazioni di commutazione nella simulazione di rete per verificare
che tutto sia impostato correttamente. Con il comando "Esegui → visualizza OVS,
visualizzeremo un riepilogo delle configurazioni dello switch. In questo caso, si può
verificare che ogni interruttore è in ascolto al controllore corretto sulla porta corretta.
Per il monitoraggio del traffico della rete, possiamo utilizzare il software Wireshark.
25
Capitolo 5: Interazione con Wireshark
Wireshark, è un software per le analisi di protocollo o packet sniffer, utilizzato per la
soluzione di problemi di rete, per l’analisi e lo sviluppo di protocolli o di software per la
comunicazione. L’analizzatore è rilasciato sotto la licenza OpenSource e gira sulla
maggior parte dei sistemi Unix e sui sistemi Microsoft Windows. Nel nostro caso,
abbiamo preferito installarlo su una macchina virtuale con Ubuntu 16.04, dove è possibile
lanciare anche il nostro emulatore Mininet.
Per semplicità, creiamo una topologia minimale con Mininet, per poterla analizzare con
Wireshark.
$ sudo mn - -topo single,3 - - mac - -switch ovsk - -controller remote
Verrà creata una topologia di rete con 3 host virtuali, 1 controller ed 1 switch.
Fig. 15 Topologia Mininet
26
Per monitorare le comunicazioni tra il controllore e lo switch della rete simulata, avviamo
Wireshark in modalità amministratore, facendo catturare il traffico sull’interfaccia di
loopback di Mininet.
$sudo wireshark &
5.1 Avvio Wireshark
Avviato Wireshark, viene presentata la seguente interfaccia :
Fig. 16 Interfaccia Wireshark
Per catturare i pacchetti in transito sull’interfaccia di loopback, selezioniamo loopback: lo
ed apriamo un secondo terminale per avviare Mininet (in modalità amministratore), con la
configurazione sopra menzionata.
Possimo notare lo scambio di messaggi OpenFLow, che avviene tra il controller e lo
27
switch. In questo modo possiamo anche fare il debug del controller. Con Wireshark, è
possibile anche visualizzare le interazioni fra controller e switch, potendo individuare
eventiali anomalie.
5.2 Configurazione Wireshark / Mininet
Possiamo impostare un filtro per selezionare i pacchetti da visualizzare per il controllo del
traffico OpenFlow, digitando "of".
A questo punto si vedranno su Wireshark, un gruppo di messaggi.
Dal momento in cui tutti i messaggi vengono inviati tramite localhost quando si utilizza
Mininet, determinare il mittente risulta ostico quando ci sono molti switch emulati.
Per ignorare i messaggi iniziali di comunicazione, basta digitare nel filtro :
of && (of.type != 1) && (of.type != 2)
Possiamo attraverso Mininet, far fare un ping da h1 ad h2.
h1 ping –c3 h2
L’host h1 invia un ARP request in broadcast, chiedendo il MAC corrispondente.
Lo switch riceve il pacchetto e non avendo flussi corrispondenti nelle sue tabelle,
inoltra il pacchetto al controller generando un messaggio OFP ti tipo PacketIn, in
cui incapsula la ARP Request dell’host h1.
Il controller riceve il messaggio e decide se concedere il broadcast, successivamente
invia allo switch un messaggio PacketOut, contenente il BufferID del pacchetto
ricevuto e l’istruzione da inoltrare il pacchetto sulla porta virtuale FLOOD, che
corrisponde a tutte le porte dello switch, esclusa quella da dove invia.
L’host h2 riceve l’ARP Request dell’host h1 e risponde con ARP Reply contenente il
proprio indirizzo MAC.
Lo switch riceve l’ARP Reply dell’host h2 ed incapsula l’ARP Reply in un
messaggio OFP di tipo PacketIn che invia al controller, poichè non ha regole nelle
28
sue tabelle.
Il controller installa nello switch una regola che consente ai pacchetti ARP Reply
inviati dall’ host h2 verso h1 di essere inoltrati verso la porta dello switch a cui è
connesso l’ultimo host, inviando allo switch un messaggio OFP di tipo FlowMod
con le specifiche della nuova regola, ovvero con le regole per il matching e le azioni
da intraprendere. In seguito all’inseguimento della regola nelle tabelle dello switch,
il dispositivo riesamina il pacchetto contenente l’ARP Reply dell’host h2 e la invia
all’host h1.
Quindi l’host h1 invia la sua ICMP Echo Request all’host h2, , e lo switch incapsula
il pacchetto in un messaggio di tipo PacketIn che invia al controller, sempre perchè
non ha una regola corrispondente.
Il controller risponde ad un FlowMod, per inserire una regola che fa inoltrare le Echo
Request provenienti dall’host h1 dirette verso l’host h2 sulla porta dello switch a cui
è connesso. Dopo l’inserimento, lo switch inoltra all'host h2 la Echo Request
dell’host h1.
L’host h2, riceve la Echo Request e invia una Echo Reply, ma lo switch dato che non
sa come inoltrare, e lo manda nuovamente al controller con un PacketIn .
Il controller risponde con un nuovo pacchetto FlowMod, che contiene la regola che
consente alle Echo Reply provenienti dall’host h2 e dirette all’host h1 di essere
inoltrate sulla porta dello switch a cui è connesso l’host h1.
Il controller risponde con un nuovo pacchetto FlowMod, contenente la regola che
consente alle Echo Reply provenienti da h2 e dirette ad h1 di essere inoltrate sulla
porta dello switch a cui è connesso l’host h1.
29
Conclusioni
Mininet, permette di creare un prototipo funzionante di una rete su cui eseguire tutti i test
necessari in maniera rapida e semplice. In questo contesto sono state create reti virtuali
elementari con test di raggiungibilità e performance molto semplici. Nella vita reale, però
è possibile implementare test più complessi che simulino applicazioni reali in grado di
essere utilizzati immediatamente. Il superamento dei test con Mininet garantisce
l’implementazione di funzioni anche sui dispositivi reali che supportano OpenFlow. Nel
caso in cui i test di performance su Mininet non sono affidabili, affiancandoli con i test
realizzati con i dispositivi reali, i risultati ottenuti forniscono comunque un’indicazione
sulla qualità delle prestazioni della rete prototipata. Infine, possiamo dire che Mininet è
molto utile per testare nuove soluzioni che risolvono problemi complicati, quindi può
essere classificato come un ottimo strumento per testare nuove implementazioni
nell’ambito delle reti.
30
Bibliografia
[1] Mininet mininet.org
[2] MiniEdit http://www.brianlinkletter.com
[3] Wireshark https://www.wireshark.org/
[4] Virtual Box https://www.virtualbox.org/
