GUIA DE APLICACIÓN DE REDES DEFINIDAS

POR SOFTWARE SDN

ASIGNATURA: REDES DE AREA LOCAL

TEMA: SDN

Ph.D. Jorge Gómez Gómez

PRIMERA PARTE: FUNDAMENTOS

TEORICOS

Definición de red definida por software (SDN)

¿Qué es SDN? La separación física del plano de control de red desde el plano
de reenvío, y donde un plano de control controla varios dispositivos.

La red definida por software (SDN) es una arquitectura emergente que es

dinámica, manejable, rentable y adaptable, lo que la hace ideal para el alto ancho
de banda y la naturaleza dinámica de las aplicaciones actuales. Esta arquitectura
desacopla las funciones de control y reenvío de la red permitiendo que el control
de red se vuelva directamente programable y que la infraestructura subyacente
se abstraiga para aplicaciones y servicios de red. El protocolo OpenFlow® es un
elemento fundamental para construir soluciones SDN.

La arquitectura SDN es:

FUENTE (https://www.opennetworking.org/sdn-definition/)

DIRECTAMENTE PROGRAMABLE

El control de red es directamente programable porque está desacoplado de las

funciones de reenvío.

ÁGIL

El control de abstracción del reenvío permite a los administradores ajustar

dinámicamente el flujo de tráfico de toda la red para satisfacer las necesidades
cambiantes.

CENTRALMENTE ADMINISTRADO

La inteligencia de red está (lógicamente) centralizada en controladores SDN

basados en software que mantienen una vista global de la red, que aparece para
las aplicaciones y los motores de políticas como un único conmutador lógico.

CONFIGURADO PROGRAMÁTICAMENTE

SDN permite a los administradores de red configurar, gestionar, asegurar y

optimizar los recursos de red de manera muy rápida a través de programas SDN
dinámicos y automatizados, que pueden escribir ellos mismos porque los
programas no dependen del software propietario.
ABIERTO BASADO EN ESTÁNDARES Y VENDEDOR-NEUTRAL

Cuando se implementa a través de estándares abiertos, SDN simplifica el diseño

y la operación de la red, ya que las instrucciones las proporcionan los
controladores SDN en lugar de múltiples dispositivos y protocolos específicos del
proveedor.

¿Qué es OpenFlow? Definición y cómo se

relaciona con SDN
OpenFlow (OF) se considera uno de los primeros estándares de redes definidas
por software (SDN) . Definió originalmente el protocolo de comunicación en
entornos SDN que permite que el controlador SDN interactúe directamente con
el plano de reenvío de los dispositivos de red, como conmutadores y
enrutadores, tanto físicos como virtuales (basados en hipervisor), para adaptarse
mejor a los requisitos comerciales cambiantes.

Un controlador SDN en SDN es el "cerebro" de la red SDN, que transmite

información a los conmutadores / enrutadores "debajo" (a través de API hacia el
sur ) y las aplicaciones y la lógica de negocios "arriba" (a través de API hacia el
norte ). Recientemente, a medida que las organizaciones implementan más
redes SDN, se les ha encomendado a los controladores SDN la federación entre
los dominios de controladores SDN, utilizando interfaces de aplicaciones
comunes, como OpenFlow y la base de datos de conmutadores virtuales abiertos
(OVSDB) .

Para trabajar en un entorno OF, cualquier dispositivo que desee comunicarse

con un controlador SDN debe ser compatible con el protocolo OpenFlow . A
través de esta interfaz, el controlador SDN empuja hacia abajo los cambios en la
tabla de flujo del conmutador / enrutador, lo que permite a los administradores
de red dividir el tráfico, controlar los flujos para un rendimiento óptimo y comenzar
a probar nuevas configuraciones y aplicaciones.
Entradas de tabla de flujo que se pueden manipular en un conmutador OF

Fuente (https://www.sdxcentral.com/sdn/definitions/what-is-openflow/)

Beneficios de OpenFlow:
Programabilidad

• Habilitar innovación / diferenciación

• Acelerar la introducción de nuevas características y servicios

Inteligencia Centralizada

• Simplificar el aprovisionamiento
• Optimizar el rendimiento
• Gestión de políticas granulares

Abstracción

• Desacoplamiento de hardware y software, plano de control y reenvío, y

configuración física y lógica.

Historial de protocolo

El concepto original para OF comenzó en la Universidad de Stanford en 2008.

En diciembre de 2009, se lanzó la versión 1.0 de la especificación del interruptor
OpenFlow. Desde su inicio, OpenFlow ha sido administrado por Open
Networking Foundation (ONF) , una organización dirigida por usuarios dedicada
a estándares abiertos y adopción de SDN.

Desde su lanzamiento, varias compañías y proyectos de código abierto como

OpenDaylight Project soncompatibles con OpenFlow e incluso proporcionan
OpenDaylight Controllers . Otras compañías como Cisco y Brocade también
ofrecen controladores habilitados para OF, con Cisco XNC y Brocade Vyatta
Controller .
¿Qué es un controlador OpenFlow?
Un Controlador OpenFlow es un tipo de Controlador SDN que usa el Protocolo
OpenFlow. Un controlador SDN es el punto estratégico en la red definida por
software (SDN) . Un controlador OpenFlow utiliza el protocolo OpenFlow para
conectar y configurar los dispositivos de red (enrutadores, conmutadores, etc.)
para determinar la mejor ruta para el tráfico de la aplicación. También hay otros
protocolos SDN que un Controlador puede usar, como OpFlex , Yang y NetConf,
por nombrar algunos.

Los controladores SDN pueden simplificar la administración de la red,

manejando todas las comunicaciones entre aplicaciones y dispositivos para
administrar y modificar de manera efectiva los flujos de red para satisfacer las
necesidades cambiantes. Cuando el plano de control de red se implementa en
software, en lugar de firmware, los administradores pueden administrar el tráfico
de red de forma más dinámica y en un nivel más granular. Un controlador SDN
transmite información a los conmutadores / enrutadores (a través de las API
hacia el sur ) y las aplicaciones y la lógica comercial (a través de las API hacia
el norte ).

En particular, los controladores OpenFlow crean un punto de control central para

supervisar una variedad de componentes de red habilitados para OpenFlow. El
protocolo OpenFlow está diseñado para aumentar la flexibilidad al eliminar los
protocolos propietarios de los proveedores de hardware.
Fuente (https://www.sdxcentral.com/sdn/definitions/sdn-controllers/openflow-
controller/)

Casos de uso de SDN y OpenFlow

Al elegir un Controlador SDN, las organizaciones de TI deben evaluar la

funcionalidad OpenFlow admitida por el Controlador, así como la hoja de ruta del
proveedor. Las organizaciones de TI deben comprender la funcionalidad
existente y asegurarse de que las versiones más nuevas de OpenFlow y las
características opcionales son compatibles (por ejemplo, la compatibilidad con
IPv6 no es parte del estándar OpenFlow v1.0, sin embargo, es parte del estándar
v1.3).

Una muestra de los controladores OpenFlow incluye:

NOX : NOX es un sistema operativo de red que proporciona control y visibilidad

en una red de switches OpenFlow. Admite aplicaciones simultáneas escritas en
Python y C ++, e incluye varias aplicaciones de controlador de muestra.

Beacon : Beacon es un Controlador OpenFlow extensible basado en Java. Fue

construido en un marco OSGI, permitiendo que las aplicaciones OpenFlow se
construyan en la plataforma para ser iniciadas / detenidas / actualizadas /
instaladas en tiempo de ejecución, sin desconectar los switches.
Helios: Helios es un Controlador OpenFlow extensible basado en C construido
por NEC , dirigido a investigadores. También proporciona un shell programático
para realizar experimentos integrados.

NEC ProgrammableFlow : flujo programable de NEC automatiza y simplifica la

administración de red para una mejor agilidad comercial, y proporciona una
interfaz programable en toda la red para unificar la implementación y
administración de servicios de red con el resto de la infraestructura de TI.
Programmable Flow es compatible con OpenFlow 1.3 y 1.0, y fue el primero en
ser certificado por Open Networking Foundation.

Controlador SDN de Brocade : El Controlador SDN de Brocade se basa en el

lanzamiento de Helium de OpenDaylight , anunciado en septiembre de 2014.
Incorpora la orquestación OpenStack , y si bien es de código abierto , Brocade
ofrecerá una versión comercial.

BigSwitch : BigSwitch lanzó un controlador de fuente cerrada basado en Beacon

que se dirige a las redes empresariales de producción. Cuenta con una CLI fácil
de usar para administrar su red de forma centralizada.

SNAC : SNAC es un controlador dirigido a redes empresariales de producción.

Está basado en NOX0.4 y presenta un lenguaje flexible de definición de políticas
y una interfaz fácil de usar para configurar dispositivos y monitorear eventos.

Maestro : Maestro es un Controlador OpenFlow extensible basado en Java

lanzado por la Universidad de Rice. Tiene soporte para multi-threading y se dirige
a investigadores.

¿Qué es el Proyecto OpenDaylight (ODL)?

Anunciado en abril de 2013, se creó OpenDaylight Project (ODL) , un proyecto
SDN de código abierto hospedado por Linux Foundation para avanzar en la
adopción de redes definidas por software (SDN) y crear las bases para una fuerte
virtualización de funciones de red (NFV) . Fue creado como un marco SDN de
fuente abierta liderado por la comunidad y apoyado por la industria . El objetivo
del proyecto OpenDaylight es ofrecer una plataforma SDN funcional que brinde
a los usuarios SDN implementados directamente sin la necesidad de otros
componentes. Además de esto, los contribuidores y proveedores pueden
entregar complementos y otras piezas que ofrecerán más valor a OpenDaylight.

Aunque la Fundación Linux aloja el Proyecto OpenDaylight, no solo se ejecuta

en plataformas Linux. Está licenciado bajo la Licencia Pública Eclipse (EPL) , a
menudo elegida para proyectos basados en Java. El uso de EPL permite a
OpenDaylight aumentar su compatibilidad con el entorno expansivo de
bibliotecas y componentes de terceros que ya se han lanzado bajo la licencia
EPL. El EPL es una licencia aprobada de código abierto y, según la Free
Software Foundation, es una licencia de software libre.

Descripción técnica general de OpenDaylight (ODL)

En febrero de 2014, OpenDaylight anunció "Hydrogen", su primer lanzamiento

de código. Está compuesto por 15 proyectos, todos desviados a tres ediciones
diferentes. La Edición Base consiste en el Controlador OpenDaylight (un
Controlador SDN ) y funcionalmente simple para probarlo, en pocas palabras, es
lo que todos necesitan para usar OpenDaylight. Tras el lanzamiento de
Hydrogen, los desarrolladores ya estaban buscando la próxima versión del
código: Helium .

Fuente (https://www.sdxcentral.com/sdn/definitions/opendaylight-project/)

Los miembros fundadores incluyeron Arista Networks , Big Switch Networks ,

Brocade , Cisco , Citrix , Ericsson , HP , IBM ,Juniper Networks , Microsoft, NEC
, Nuage Networks , PLUMGrid , Red Hat yVMware. (Nota: Juniper, Microsoft y
VMware abandonaron ODL en 2015). Los miembros iniciales donaron los
recursos necesarios para ayudar a crear una red de fuente abierta de grupos
centrados en avanzar en la plataforma SDN. La membresía en el Proyecto
OpenDaylight ahora consta de tres niveles: Platino, Oro y Plata, que ofrecen
diferentes cantidades de contribución. Los miembros Platinum deben
comprometer a 10 desarrolladores para el proyecto, con solo tres
desarrolladores de miembros Gold.

A pesar de sus miembros fundadores, OpenDaylight no tiene una sola compañía

o grupo de compañías que "lideren" el proyecto. En cambio, opera a través de
una comunidad abierta y activa que está disponible para que cualquiera se una.
El requisito para unirse es contribuir a la apertura de la comunidad, por lo tanto,
quienes se unen ofrecen asistencia en una variedad de áreas, desde la
codificación hasta el liderazgo de la Junta Directiva . Este último gestiona el
aspecto comercial de OpenDaylight, incluidas las decisiones operativas y de
marketing. No hay un requisito monetario para ser parte del Proyecto
OpenDaylight.

El Comité Directivo Técnico (TSC) maneja la supervisión de las actividades de

diseño y desarrollo del Proyecto OpenDaylight. El TSC también está a cargo de
las fechas de lanzamiento, los estándares de calidad de los lanzamientos, las
mejores prácticas técnicas, el monitoreo del progreso técnico, la medicación de
conflictos técnicos entre los colaboradores y los líderes del proyecto, así como
la gestión de la colaboración entre proyectos. Cualquiera que pueda desarrollar
y contribuir con un código puede ser elegido para el TSC, y posteriormente
votado a la Junta. Esto permite que los contribuyentes con visión puedan dejar
su huella en el Proyecto OpenDaylight.

OpenDaylight utiliza los estándares abiertos actualmente, gracias al trabajo con

líderes como Open Networking Foundation (ONF) . OpenFlow es un ejemplo
principal de un protocolo SDN admitido por OpenDaylight, y a medida que se
crean nuevos productos en el futuro, OpenDaylight Project asumirá esos
estándares también. Existe un entendimiento común dentro de la industria que
aunque OpenFlow es beneficioso en varios escenarios, SDN no es solo
OpenFlow o cualquier otro protocolo. Por lo tanto, el Proyecto OpenDaylight está
destinado a configurar varias interfaces SDN, incluido, entre otros, OpenFlow.

SEGUNDA PARTE: GUÍA DE APLICACIÓN

Se descarga mininet del siguiente link

http://mininet.org/download/

Virtualbox

https://www.virtualbox.org/wiki/Downloads

Xming

https://sourceforge.net/projects/xming/

Luego en lo montamos en máquina virtual y habilitamos PAE/NX en sistema y

procesador
Y en red escogemos adaptador puente para una ip automática o podemos
asignarla de modo manual

TIPS
Leyenda
Hx → Host
Sx → Switch
Cx → Controller
$ → comando en shell
# → comandos como root

Syntaxys:
mininet>[nodo] comando
-  Colocando el nodo frente a un comando, indicamos que el
comando está siendo ejecutado en aquel nodo
- Es posible utilizar el nombre del nodo para sustituir la IP.
mininet>h2 ping -c5 h3

mininet>exit
Salir de mininet

mininet>xterm [nodo]
Abre un terminal para el nodo.

mininet>link [node1][node2][up or down]

Crea o elimina un o link entre dos nodos

mininet>pingall
Prueba conectividad entre dos nodos
mininet>help
Ayuda, muestra lista de comandos de mininet

#mn -c
 Limpia la topología

Topología
A continuación se explicarán 4 tipos de topologías
que pueden ser utilizadas en Mininet:
• single
• linear
• tree
• custom.

Mininet> → comandos dentro de mininet

E iniciamos la maquina el usuario y contraseña es mininet y ponemos el super

usuario

Luego vemos nuestra IP con ifconfig

Después abrimos PuTTY o XMNG

Configuración PuTTY

Ponemos nuestra IP

Y habilitamos o marcamos la opción de activar X11

E iniciamos Sesión
CONFIGURACION XMING

Antes de ejecutar XMing hay que realizar los siguientes ajustes

En la terminal de Putty entre a mininet y entre a esta dirección /etc/ssh/

Ejecute la siguiente instrucción

Nano sshd_config

A continuación, busque en el cuerpo de la configuración

La siguiente línea X11Forwarding yes

En caso de que no esté adiciónela y agregue las siguientes líneas

X11Forwarding yes
X11DisplayOffset 10
X11UseLocalhost yes
XAuthLocation /usr/bin/X11/xauth
Guarde los cambios y cierre el archivo.

Esta instrucción permitirá ejecutar de forma gráfica el Xming en windows

A continuación, ejecute XMing

Una vez ejecutado el servido Xming, ejecute XLaunch
Marcamos Múltiple Windows y en Display number ponga 2
Iniciar un programa / Start a program

Usar PuTTY
Y luego siguiente hasta llegar a finalizar

Nos saldrá algo como esto.

TOPOLOGIAS EN MININET
SINGLE: Un switch conectado a N hosts.

$sudo mn --topo single,N

Siendo N la cantidad de hosts deseados

Pingall Prueba conectividad los nodos

Y con h1 ping h2 probamos la conexión en esos 2 puntos

Linear: Cada switch se conecta con otro de forma linear, y cada switch tiene un
host conectado.

$sudo mn --topo linear,N

N será el número de switches y hosts.

Y probamos la conexión
Tree: Crea una topologia de arbol con profundidad N y anchura M.

$sudo mn --topo=tree,depth=n,fanout=m

Y por último probamos en ping

Analizar Tráfico con Tcpdump

Para este ejemplo requerimos de dos ventanas de comandos extra

Vemos las nuevas pestañas, si tecleamos ifconfig notamos que también se
agregan tarjetas de red virtuales

Analizar Trafico con Wireshark

Luego hacemos un ping de h1 a h2.

Y en las ventanas de xterm ponemos

tcpdump -i h1-eth0

tcpdump -i h2-eth0

siendo h-eth0 la tarjeta de red correspondiente para cada uno

Si al teclear xterm no aparece nada podemos hacer lo mismo con varias pestañas de PuTTY

Y se hace tcpdump a las tarjetas de red correspondientes

Al lado derecho se observa la captura realizada por tcpdump

Para abrir wireshark tecleamos

Ejecutando topologías desde codigo python

A continuación siga las siguientes instrucciones:

Crear una carpeta en /home

Llamada test_network

Genere un archivo llamado single_topo.py

Digite la siguiente información:

#!/usr/bin/python

from mininet.topo import Topo

from mininet.net import Mininet
from mininet.util import dumpNodeConnections
from mininet.log import setLogLevel

class SingleSwitchTopo(Topo):
"Single switch connected to n hosts."
def build(self, n=2):
switch = self.addSwitch('s1')
# Python's range(N) generates 0..N-1
for h in range(n):
host = self.addHost('h%s' % (h + 1))
self.addLink(host, switch)

def simpleTest():
"Create and test a simple network"
topo = SingleSwitchTopo(n=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()

Tenga en cuenta las siguientes consideraciones:

Important classes, methods, functions and variables in the above code include:

Topo: the base class for Mininet topologies

 build(): The method to override in your topology class. Constructor parameters (n) will be passed
through to it automatically by Topo.__init__().
addSwitch(): adds a switch to a topology and returns the switch name
addHost(): adds a host to a topology and returns the host name
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.

Para ejecutar el archivo siga la siguiente instrucción

sudo python single_topo.py

La salida es esta

*** Creating network

*** Adding controller
*** Adding hosts:
h1 h2 h3 h4
*** Adding switches:
s1
*** Adding links:
(h1, s1) (h2, s1) (h3, s1) (h4, s1)
*** Configuring hosts
h1 h2 h3 h4
*** Starting controller
c0
*** Starting 1 switches
s1 ...
Dumping host connections
h1 h1-eth0:s1-eth1
h2 h2-eth0:s1-eth2
h3 h3-eth0:s1-eth3
h4 h4-eth0:s1-eth4
Testing network connectivity
*** Ping: testing ping reachability
h1 -> h2 h3 h4
h2 -> h1 h3 h4
h3 -> h1 h2 h4
h4 -> h1 h2 h3
*** Results: 0% dropped (12/12 received)
*** Stopping 1 controllers
c0
*** Stopping 4 links
....
*** Stopping 1 switches
s1
*** Stopping 4 hosts
h1 h2 h3 h4
 *** Done

A continuación digite el siguiente código en un archivo llamado sigle_loop.py

#!/usr/bin/python

from mininet.topo import Topo

from mininet.cli import CLI

from mininet.net import Mininet
from mininet.util import dumpNodeConnections
from mininet.log import setLogLevel

from mininet.node import RemoteController

REMOTE_CONTROLLER_IP = "127.0.0.1"

def simpleTest():
# Create and test a simple network
topo = SingleLoopTopo()

net = Mininet(topo=topo,
controller=None,
autoStaticArp=True)
net.addController("c0",
controller=RemoteController,
ip=REMOTE_CONTROLLER_IP,
port=6633)
net.start()
print "Dumping host connections"
dumpNodeConnections(net.hosts)
print "Testing network connectivity"
net.pingAll()
net.stop()

class SingleLoopTopo(Topo):
# Single switch connected to n hosts
def __init__(self, **opts):
# Initialize topology and default optioe
Topo.__init__(self, **opts)
switches = []
hosts = []

# create switches
for s in range(3):
switches.append(self.addSwitch('s%s' % (s + 1), protocols='OpenFlow13'))

# create hosts
for h in range(4):
hosts.append(self.addHost('h%s' % (h + 1)))

self.addLink(hosts[0], switches[1])
self.addLink(hosts[1], switches[1])
self.addLink(hosts[2], switches[2])
self.addLink(hosts[3], switches[2])
 self.addLink(switches[0], switches[1])
self.addLink(switches[0], switches[2])
self.addLink(switches[1], switches[2])

if __name__ == '__main__':
# Tell mininet to print useful information
setLogLevel('info')
simpleTest()
topo = SingleLoopTopo()
net = Mininet(topo=topo,
controller=None,
autoStaticArp=True)
net.addController("c0",
controller=RemoteController,
ip=REMOTE_CONTROLLER_IP,
port=6633)
net.start()
CLI(net)
net.stop()

Ejecútelo y la salida debe ser como esta:

mininet@mininet-vm:/home/pmininet$ sudo python simple_loop.py

*** Creating network

*** Adding hosts:
h1 h2 h3 h4
*** Adding switches:
s1 s2 s3
*** Adding links:
(h1, s2) (h2, s2) (h3, s3) (h4, s3) (s1, s2) (s1, s3) (s2, s3)
*** Configuring hosts
h1 h2 h3 h4
Unable to contact the remote controller at 127.0.0.1:6633
*** Starting controller
c0
*** Starting 3 switches
s1 s2 s3 ...
Dumping host connections
h1 h1-eth0:s2-eth1
h2 h2-eth0:s2-eth2
h3 h3-eth0:s3-eth1
h4 h4-eth0:s3-eth2
Testing network connectivity
*** Ping: testing ping reachability
h1 -> X X X
h2 -> X X X
h3 -> X X X
h4 -> X X X
*** Results: 100% dropped (0/12 received)
*** Stopping 1 controllers
c0
*** Stopping 7 links
.......
*** Stopping 3 switches
s1 s2 s3
*** Stopping 4 hosts
h1 h2 h3 h4
*** Done
*** Creating network
*** Adding hosts:
h1 h2 h3 h4
*** Adding switches:
s1 s2 s3
*** Adding links:
(h1, s2) (h2, s2) (h3, s3) (h4, s3) (s1, s2) (s1, s3) (s2, s3)
*** Configuring hosts
h1 h2 h3 h4
Unable to contact the remote controller at 127.0.0.1:6633
*** Starting controller
c0
*** Starting 3 switches
s1 s2 s3 ...
*** Starting CLI:
Creaando topologías personalizadas en python

Figure 1

Crear un archivo en python

vi ~/mininet/custom/multi-hosts.py

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

Host1 = self.addHost( 'h1' )

Host2 = self.addHost( 'h2' )

Host3 = self.addHost( 'h3' )

Host4 = self.addHost( 'h4' )

Host5 = self.addHost( 'h5' )

Host6 = self.addHost( 'h6' )

Switch0 = self.addSwitch('s0')

Switch1 = self.addSwitch('s1')

Switch2 = self.addSwitch('s2')

# Add links

self.addLink( Host1, Switch0 )

self.addLink( Host2, Switch0 )

self.addLink( Host3, Switch0 )

self.addLink( Host4, Switch1 )

 self.addLink( Host5, Switch1 )

self.addLink( Host6, Switch1 )

self.addLink( Switch0, Switch2 )

self.addLink( Switch2, Switch1 )

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

Start the topology and enter Mininet CLI

run

mininet@mininet-vm:~$ sudo mn --custom ./mininet/custom/multi-hosts.py

--topo=mytopo

***Creating network
***Adding controller
***Adding hosts:
h1 h2 h3 h4
***Adding switches:
s1 s2
***Adding links:
(h1, s1) (h2, s1) (h3, s2) (h4, s2) (s1, s2) ***Configuring hosts
h1 h2 h3 h4
***Starting controller
c0
***Starting 2 switches
s1 s2
***Starting CLI:
mininet>

Display nodes

mininet> nodes

available nodes are:

c0 h1 h2 h3 h4 s1 s2

Display links
mininet> links

h1-eth0<->s1-eth1 (OK OK)

h2-eth0<->s1-eth2 (OK OK)

h3-eth0<->s2-eth1 (OK OK)

h4-eth0<->s2-eth2 (OK OK)

s1-eth3<->s2-eth3 (OK OK)

Display net

mininet> net

h1 h1-eth0:s1-eth1

h2 h2-eth0:s1-eth2

h3 h3-eth0:s2-eth1

h4 h4-eth0:s2-eth2

s1 lo: s1-eth1:h1-eth0 s1-eth2:h2-eth0 s1-eth3:s2-eth3

s2 lo: s2-eth1:h3-eth0 s2-eth2:h4-eth0 s2-eth3:s1-eth3

c0

Display h1's interface configuration

mininet> h1 ifconfig

h1-eth0 Link encap:Ethernet HWaddr 8e:4f:d8:24:e1:e6

inet addr:10.0.0.1 Bcast:10.255.255.255 Mask:255.0.0.0

inet6 addr: fe80::8c4f:d8ff:fe24:e1e6/64 Scope:Link

 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1

RX packets:17 errors:0 dropped:0 overruns:0 frame:0

TX packets:8 errors:0 dropped:0 overruns:0 carrier:0

collisions:0 txqueuelen:1000

RX bytes:1326 (1.3 KB) TX bytes:648 (648.0 B)

lo Link encap:Local Loopback

inet addr:127.0.0.1 Mask:255.0.0.0

inet6 addr: ::1/128 Scope:Host

UP LOOPBACK RUNNING MTU:65536 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:0

RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)