IMPLEMENTACIÓN DE UN GENERADOR DE TOPOLOGÍAS
Anuncio
IMPLEMENTACIÓN DE UN GENERADOR DE TOPOLOGÍAS ALEATORIAS EN
EL EMULADOR DE RED MININET
Rosa Alejandra García Grisales
Diego Fernando Hernández Ossa
Juan Carlos Agudelo Calderón
Universidad Católica De Pereira
Facultad De Ciencias Básicas E Ingeniería
Ingeniería De Sistemas Y Telecomunicaciones
Pereira, 2015
IMPLEMENTACIÓN DE UN GENERADOR DE TOPOLOGÍAS ALEATORIAS EN
EL EMULADOR DE RED MININET
Autores: Rosa Alejandra García Grisales
Juan Carlos Agudelo Calderón
Rosa Alejandra García Grisales
Director del Proyecto: Ingeniero Néstor Álzate Mejía
Trabajo de grado para optar al título de profesional en Ingeniería en Sistemas y
Telecomunicaciones
Universidad Católica De Pereira
Facultad De Ciencias Básicas E Ingeniería
Ingeniería De Sistemas Y Telecomunicaciones
Pereira, 2015
AGRADECIMIENTOS
A mi padre, madre, hermano por su apoyo incondicional y ser el motor para
alcanzar este logro
Al ingeniero Néstor Álzate por su paciencia, acompañamiento y enseñanza.
Rosa Alejandra García Grisales
A mi familia por el apoyo incondicional, por el acompañamiento y por la motivación
para lograr este sueño.
Al ingeniero Néstor Álzate por su gran participación, ayuda y acompañamiento a lo
largo del proyecto.
Diego Fernando Hernández Ossa
A mi esposa e hijos, que han aportado su espacio y tiempo como apoyo
incondicional para lograr este objetivo.
A nuestro director, ingeniero Néstor Álzate, que nos abre la mente para afrontar y
entender el cambio inminente de estas nuevas tecnologías.
Juan Carlos Agudelo Calderón
RESUMEN
La arquitectura de las redes actuales están limitadas, son costosas y complejas de
administrar, las Redes Definidas por Software (SDN por sus siglas en inglés) nacen
para innovar en las redes, su elemento clave es la separación de los datos y el
plano de control, elimina el plano de control del hardware de red e implementa en
software en su lugar, lo que permite el acceso virtual y, como resultado, hace que
la administración de red sea mucho más dinámica, flexible, adaptable a los
requisitos de la red, además de permitir la rápida configuración y reconfiguración
para mejorar la utilización de recursos y las actuaciones de servicios.
El presente proyecto contribuye a la comunidad académica, especialmente que se
encuentra compartiendo sus avances en GitHub1 y a los estudiantes de la
Universidad Católica de Pereira que están realizando su trabajo de grado en el tema
de las SDN, proponiendo la solución de un Generador de Topologías Aleatorias en
la API del emulador Mininet, que es una aplicación desarrollada para investigación,
practica, pruebas y desarrollo de prototipos SDN en tiempo real.
Palabras Clave: Redes Definidas por Software, Mininet, Generador de Topología.
1
Git Hub plataforma de desarrollo colaborativo de software para alojar proyectos y contribuir a otros
desarrollos.
4
ABSTRACT
The architecture of today's networks are limited, they are expensive and complex to
administer networks defined by Software (SDN for its acronym in English) born to
innovate in networks, the key element is the separation of data and control plane
eliminates the control plane and network hardware implemented in software in place,
allowing virtual access and as a result, makes network management is much more
dynamic, flexible, adaptable to the requirements of the network, In addition to
allowing quick configuration and reconfiguration to improve resource utilization and
performance of services.
This project contributes to the academic community, especially that is sharing its
progress on GitHub and students of the Catholic University of Pereira who are doing
their job grade in the subject of the SDN, proposing a solution to a Topology Builder
Random API emulator in Mininet, which is an application developed for research,
practice, testing and prototyping SDN in real time.
Keywords: software-defined networking, Mininet, Topology Generator.
5
TABLA CONTENIDO
TABLA CONTENIDO ...................................................................................................................................... 6
TABLA DE ILUSTRACIONES............................................................................................................................ 8
LISTADO DE TABLAS ................................................................................................................................... 11
1. INTRODUCCION ...................................................................................................................................... 12
2. FORMULACIÓN DEL PROBLEMA ............................................................................................................. 14
3. OBJETIVOS.............................................................................................................................................. 15
3.2 OBJETIVO GENERAL................................................................................................................................. 15
3.3 OBJETIVOS ESPECÍFICOS .......................................................................................................................... 15
4. JUSTIFICACIÓN ....................................................................................................................................... 16
5. METODOLOGIA ...................................................................................................................................... 17
6. MARCO CONTEXTUAL ............................................................................................................................ 18
7. ANTECEDENTES ...................................................................................................................................... 21
7.2 MARCO CONCEPTUAL ............................................................................................................................. 22
7.2.1 SDN .................................................................................................................................................. 22
7.2.2 OpenFlow ........................................................................................................................................ 26
Switch Openflow ...................................................................................................................................... 26
Protocolo Openflow ................................................................................................................................. 28
Controladores............................................................................................................................................ 28
7.2.3 Mininet ............................................................................................................................................ 31
API Mininet ............................................................................................................................................... 36
7.2.4 Modelo de Grafo Aleatorio .............................................................................................................. 39
7.2.9 Generadores de Topologías ............................................................................................................. 45
8. IMPLEMENTACION ................................................................................................................................. 50
8.1 LIBRERIAS INSTALADAS PARA EJECUTAR LA TOPOLOGIA WAXMAN ...................................................... 51
8.3 VALIDACIÓN ............................................................................................................................................ 52
8.4 CALCULO DEL ÁREA ................................................................................................................................. 53
8.5 NODOS .................................................................................................................................................... 54
6
8.6 DISTRIBUCIÓN DE NODOS ....................................................................................................................... 54
8.7 DEFINICIÓN DE DISTANCIAS .................................................................................................................... 55
8.8 DEFINICIÓN DE PROBABILIDADES ........................................................................................................... 56
8.9 ASIGNACIÓN DE HOST A LOS N NODOS .................................................................................................. 57
8.9.2 Importación de librerías de Mininet. ............................................................................................... 57
8.10 INCLUSIÓN EN LA API ............................................................................................................................ 60
8.11 RESULTADO ........................................................................................................................................... 61
8.12 OBSERVACIONES ................................................................................................................................... 62
9. PRESUPUESTO ........................................................................................................................................ 63
10. CRONOGRAMA ..................................................................................................................................... 65
11. CONCLUSIONES Y RECOMENDACIONES ................................................................................................ 66
REFERENCIAS ............................................................................................................................................. 67
BIBLIOGRAFIA ............................................................................................................................................ 73
ANEXO 1..................................................................................................................................................... 79
GUÍA DE INSTALACIÓN MININET................................................................................................................... 79
INSTALACIÓN NATIVA DE MININET EN UBUNTU 14.04. ........................................................................... 79
LISTADO DE COMANDOS UTILES EN MININET .............................................................................................. 81
COMANDOS PARA GENERAR TOPOLOGIAS .............................................................................................. 81
COMANDOS DE PRUEBAS ......................................................................................................................... 83
COMANDOS FUNCIONALES ...................................................................................................................... 87
INSTALACION DE LIBRERÍAS Y PAQUETES REQUERIDOS ............................................................................... 89
EJECUCIÓN ARCHIVO PYTHON ...................................................................................................................... 92
CREAR Y EDITAR TOPOLOGÍAS DESDE EL EDITOR NANO EN UBUNTU .......................................................... 94
CONTROLADOR POR DEFECTO DE MININET POX.......................................................................................... 95
ANEXO 2..................................................................................................................................................... 96
CÓDIGO PYTHON TOPOLOGÍA WAXMAN.PY ................................................................................................ 96
7
TABLA DE ILUSTRACIONES
Ilustración 1. Arquitectura lógica de las redes definidas por software .................... 24
Ilustración 2 Switch Openflow ................................................................................ 27
Ilustración 3. Funciones de Switch......................................................................... 28
Ilustración 4. Esquema básico de un controlador de red ....................................... 30
Ilustración 5. Diagrama de flujo de las funciones de un controlador ...................... 31
Ilustración 6. Dispositivo virtual de Mininet ............................................................ 32
Ilustración 7. Topologia de Red simulada .............................................................. 35
Ilustración 8. Ejemplo simulacion Mininet .............................................................. 36
Ilustración 9. Nodos y enlaces ............................................................................... 37
Ilustración 10. Objeto de red .................................................................................. 38
Ilustración 11. Plantilla de topología ...................................................................... 38
Ilustración 12. Modelo de Waxman ........................................................................ 40
Ilustración 13. Modelo Erdos-Renyi. ..................................................................... 41
Ilustración 14. Modelo Barabasi-Albert .................................................................. 43
Ilustración 15. Modelo Watts-Strogatz ................................................................... 44
Ilustración 16. Interfaz de usuario para la versión Bessie ...................................... 47
Ilustración 17. NEM................................................................................................ 48
Ilustración 18. Grafica de Brite ............................................................................... 49
Ilustración 19. Captura de pantalla IGen con una topología entre dominios .......... 50
Ilustración 20. Librerías importadas ....................................................................... 51
Ilustración 21. Definición de la Función Waxman .................................................. 52
Ilustración 22. Validación de ingreso de datos ....................................................... 53
Ilustración 23. Tupla Límite .................................................................................... 53
Ilustración 24. Calculo área ................................................................................... 53
Ilustración 25. Calculo de nodos ........................................................................... 54
8
Ilustración 26. Distribución de nodos ..................................................................... 55
Ilustración 27. Distribución en los ejes X y Y ........................................................ 55
Ilustración 28. Coordenadas del Vector Fuente: Elaboración propia ..................... 56
Ilustración 29. Matriz de distribución ...................................................................... 56
Ilustración 30. Matriz de probabilidades ................................................................. 57
Ilustración 31. Matriz de adyacencia ...................................................................... 57
Ilustración 32.Definición de la clase ....................................................................... 58
Ilustración 33. Importación de la clase topo ........................................................... 58
Ilustración 34. Definición nodos y asignación host................................................. 59
Ilustración 35. Definiendo Waxman como clase tipo Topo .................................... 59
Ilustración 36. Ejemplo ejecución topología ........................................................... 60
Ilustración 37. Otro Ejemplo ejecución topología ................................................... 60
Ilustración 38. Ejecución Waxman.py .................................................................... 61
Ilustración 39. Cronograma .................................................................................... 65
Ilustración 40. Terminal Ubuntu ............................................................................. 79
Ilustración 41. Instalar Mininet desde terminal ....................................................... 80
Ilustración 42. Instalar Mininet ............................................................................... 80
Ilustración 43. sudo mn --test pingall ..................................................................... 80
Ilustración 44. sudo mn .......................................................................................... 81
Ilustración 45. sudo topo single.............................................................................. 81
Ilustración 46. sudo topo linear .............................................................................. 82
Ilustración 47. sudo topo tree ................................................................................. 82
Ilustración 48. link .................................................................................................. 83
Ilustración 49. h1 ping h2 ....................................................................................... 83
Ilustración 50. pingall ............................................................................................. 83
Ilustración 51. pingpair ........................................................................................... 84
Ilustración 52. iperf ................................................................................................. 84
Ilustración 53. nodes .............................................................................................. 84
Ilustración 54. dump............................................................................................... 84
9
Ilustración 55. net................................................................................................... 85
Ilustración 56. eof................................................................................................... 85
Ilustración 57. s1 arp .............................................................................................. 85
Ilustración 58. h1 if config ...................................................................................... 86
Ilustración 59. s1 ifconfig ....................................................................................... 86
Ilustración 60. h1 ps ............................................................................................... 87
Ilustración 61. s1 ps ............................................................................................... 87
Ilustración 62. exit .................................................................................................. 87
Ilustración 63. help ................................................................................................. 88
Ilustración 64. sudo su ........................................................................................... 88
Ilustración 65. Instalación librería FNSS ................................................................ 89
Ilustración 66. Instalación Wireshark ..................................................................... 89
Ilustración 67. Instalación librerías ......................................................................... 90
Ilustración 68. Instalación librería matpotlib ........................................................... 91
Ilustración 69. Ingreso a ruta desde la API ............................................................ 92
Ilustración 70. Abrir archivo python Waxman.py .................................................... 92
Ilustración 71. Ejecución Waxman.py .................................................................... 93
Ilustración 72. Vista ejecución archivo Waxman.py ............................................... 93
Ilustración 73. Editor nano ..................................................................................... 94
Ilustración 74. Modificación de archivo desde nano............................................... 94
10
LISTADO DE TABLAS
Tabla 1. Equipos Cómputo .................................................................................... 63
Tabla 2. Costos Administrativos............................................................................. 63
Tabla 3. Presupuesto de Inversiones ..................................................................... 64
11
1. INTRODUCCION
Las arquitecturas de las redes actuales, fueron pensadas para que el control,
enrutamiento y la señalización de la red, fuesen parte de una estructura de gestión
estática, jerárquica y dependientes de la infraestructura de red. Una de sus grandes
dificultades sigue siendo la imposibilidad de realizar cambios de modo dinámico, en
función de requerimientos de tráfico o servicios, aumentando significativamente la
complejidad, el costo de administración y gestión de la red. La red tradicional de
datos ha estado en gran medida centrada en hardware. Sin embargo, en los últimos
años la adopción de dispositivos de red virtualizados y el interés creciente han
liderado un movimiento hacia una mayor dependencia de la funcionalidad de red
basada en el software.
Para superar las limitaciones de las redes tradicionales han surgido herramientas
como Mininet2 y Organizaciones sin ánimo de lucro como la ONF (Open Networking
Foundation) que están apoyando el desarrollo de las SDN, que permiten realizar
control, administración y ajustes dinámicos de la red, su inteligencia está
centralizada en los controladores, que mantienen una visión global de la red,
controla y configura los nodos para dirigir correctamente los flujos de tráfico y decide
el mejor camino, optimiza los recursos de red muy rápidamente a través de
aplicaciones dinámicas y automatizadas, que podemos programar nosotros mismos
ya que no dependen del software del fabricante. Las instrucciones son
proporcionadas por los controladores en lugar de múltiples dispositivos,
proveedores específicos y protocolos.
Cómo contribución a las SDN, nace la idea de implementar una herramienta que
realice la creación de topologías de una manera más ágil ya que la configuración de
un escenario completo de red y la aplicación en un simulador o emulador tardaría
demasiado tiempo y es muy propenso a errores. Este proyecto permite que se
puedan realizar estudios de protocolos de comunicaciones, estudiar
comportamientos de las topologías y así mismo desarrollar nuevos servicios. En el
mercado existen diferentes generadores de topologías que ofrecen diferentes
servicios todos enfocados a la reducción de tiempo pero ninguno de ellos se ha
desarrollado sobre Mininet.
2
Mininet: Emulador de Redes Definidas por Software
12
Para el éxito de este proyecto se tuvo que llevar a cabo un proceso de consulta
amplio, que incluye estudios en el lenguaje de programación Python, práctica de las
funcionalidades de la API Mininet, modelos de generadores de topologías
aleatorias, a partir del cual se determina implementar el Modelo Waxman, un modelo
de grafos aleatorios para modelar topologías de red y tiene el propósito de evaluar
los algoritmos de enrutamiento(Waxman, 1988).
El presente documento tiene plasmadas las bases teóricas y el desarrollo del
Generador de Topologías Aleatorias propuesto con el que se pretende realizar un
aporte importarte a la comunidad académica para próximos desarrollos en SDN.
13
2. FORMULACIÓN DEL PROBLEMA
Durante mucho tiempo, las tecnologías de red han evolucionado a un menor ritmo
en comparación al desarrollo de aplicaciones y servicios ofrecidos por las redes.
Los dispositivos de red como switches y routers se han desarrollado
tradicionalmente por cada fabricante, quienes diseñan su propio firmware y otros
softwares para operar y administrar sus propios equipos, cerrando la posibilidad de
programar nuevas funciones. Esto dificulta el avance de las innovaciones en las
redes, causando un aumento en la gestión y los costos de operación. Por lo tanto
las comunidades de investigación y líderes del mercado industrial han colaborado
con el fin de repensar el diseño de las redes tradicionales, trayendo como resultado
las Redes Definidas por Software.
Para apoyar la práctica e investigación de funciones, desarrollos y protocolos,
actualmente existen emuladores de red que están permitiendo evaluar el
rendimiento de una red de manera eficiente y permiten realizar pruebas de nuevos
desarrollos. El emulador Mininet es un banco de pruebas de red sin costo y
fácilmente configurable, y hasta ahora es la herramienta más conocida de apoyo a
la investigación de las SDN. (Wang, 2014)
Debido a que en las redes actuales son simples y en Mininet es posible personalizar
topologías de red, la propuesta de este proyecto es integrar a la API del emulador,
un generador de topologias aleatorio que ayudará a realizar pruebas e
investigaciones de manera más ágil.
14
3. OBJETIVOS
3.2 OBJETIVO GENERAL
Implementar un generador de topologías aleatorias con la API de Mininet, que
facilite la experimentación e investigaciones en el campo de las Redes Definidas
por Software.
3.3 OBJETIVOS ESPECÍFICOS
Estudiar y seleccionar un algoritmo para la generación de topologías
aleatorias.
Analizar los componentes y funcionalidades principales de la API Mininet
para la adaptación del algoritmo seleccionado.
Programar en el lenguaje Python el algoritmo seleccionado en la API MiniNet.
Documentar el desarrollo e implementación del software propuesto.
15
4. JUSTIFICACIÓN
El impacto que tienen las SDN en industria y en la sociedad, la red estática de hoy
puede convertirse en una plataforma de prestación de servicios amplia capaz de
responder rápidamente a las necesidades cambiantes del negocio, de los usuarios
finales, y del mercado. La necesidad de una nueva arquitectura de red, la explosión
de los dispositivos móviles y de la información, la virtualización de servidores, y
advenimiento de servicios en la nube son algunas de las tendencias que impulsan
la creación de redes en la industria para reexaminar las arquitecturas de red
tradicionales. (Foundation, Open Networking Foundation, 2012).
Existen varios generadores de topología a disposición de la comunidad
investigadora. Algunos de ellos tienen como objetivo principal generar topologías
aleatorias, otros pretenden imitar las propiedades jerárquicas de Internet. Al
seleccionar uno para un estudio en particular depende de varios
factores, incluyendo la naturaleza del estudio a realizar, el tamaño de la topología,
y determinar características de las topologías (por ejemplo, la estructura jerárquica
o propiedades de conectividad, tales como el grado de distribución de los nodos).
Con la motivación de apoyar el avance de las SDN, surge la idea de la
implementación de un generador de topologías aleatorias, aunque el emulador
Mininet permite crear modelos personalizadas, genera redes simples las cuales
limitan la investigación. La idea desarrollada en este proyecto brindará una
herramienta que generará topologías aleatoriamente permitiendo de una manera
más ágil la generación, de tal manera que facilitará su estudio, así como realizar
pruebas, implementar nuevos servicios, evolucionar nuevos protocolos, entre otros.
Los generadores de topologías proporcionan capacidades para analizar las
topologías de conjuntos de datos, asignar parámetros de configuración deseados,
proporcionan métodos para configurar la red y parámetros del tráfico(Saino, A
Toolchain for Simplifying Network Simulation Setup, 2014).
16
5. METODOLOGIA
Para el desarrollo del proyecto, se tomó como fortaleza las habilidades adquiridas,
capacitación en lenguajes, asesorías, recursos tecnológicos obtenidos. Sin
embargo, cabe anotar que para lograr los objetivos se tuvo grandes dificultades
debido que el sistema es novedoso. La mayor parte de la información se encuentra
en inglés y la poca documentación en español son traducciones del texto original.
A continuación se enumeran los pasos a seguir para el cumplimiento de los
objetivos:
1. Recopilación de información
Consultar y estudiar los algoritmos para la generación de topologías
aleatorias, generadores de topologías aleatorias existentes, tutoriales,
documentación del lenguaje de programación Python y funcionalidades
principales de la API Mininet.
2. Implementación y pruebas
Desarrollar el código con el lenguaje de programación Pyhton en la API de
Mininet y pruebas.
3. Documentación del Proyecto
Plasmar la conceptualización obtenida a lo largo del proyecto y documentar
el desarrollo.
17
6. MARCO CONTEXTUAL
La ingeniería de hardware sigue evolucionando y avanza a pasos agigantados, la
capacidad de hacer el mejor uso de la infraestructura de red se ve limitada por las
normas y protocolos rígidos o exclusivos de cada fabricante.
SDN está revolucionando la creación de redes en la industria, ofreciendo una
multitud de opciones a todos los interesados: empresarios, operadores de redes,
proveedores de servicios, empresas en general, investigadores y estudiantes.
Las Universidades a nivel mundial están investigando sobre Redes Definidas por
Software, de tal manera que están ofreciendo cursos de capacitación en SDN,
debido a que la industria de las telecomunicaciones no está preparada para recibir
esta revolución de las redes; enfocando a los profesionales de las TI en este nuevo
campo con una visión más amplia para aprovechar las ventajas que ofrecen las
redes programables.
Este proyecto está dirigido y desarrollado principalmente a la comunidad académica
de la Universidad Católica de Pereira y a la comunidad GitHub que estén
adelantando investigaciones en las SDN.
A continuación universidades que están adelantando estudios sobre las SDN:
Open NetworkingResearch Center- Universidad de Stanford
Como co-inventores de OpenFlow y SDN, abren un laboratorio de investigación que
permitirá a la industria de las comunicaciones construir redes programables que
ofrecen una mayor funcionalidad, más económicas y más fáciles de usar. (ONRC
Research, 2014)
SDN Academy-Universidad de Stanford
Permite a las empresas de redes y profesionales de TI aprovechar al máximo esta
oportunidad. Se formó en torno a un grupo de investigadores de la Universidad de
Stanford que han estado al frente de la iniciativa SDN desde su creación. Ellos han
llevado el movimiento abierto de redes durante los últimos seis años y encabezó el
desarrollo de SDN a través de un sinnúmero de demos, proyectos de código abierto,
tutoriales y prototipos. (SDN Academy, 2015)
18
North Carolina State University-Universidad Carolina del Norte
Se ha asociado con organizaciones regionales para explorar redes definidas por
software (SDN), para llevar a cabo investigaciones. El banco de pruebas se utilizará
para transferir grandes conjuntos de datos de investigación y permitir la
experimentación regional con tecnologías SDN. Con el tiempo, permitirá a las
instituciones construir dinámicamente circuitos de investigación a través de las
redes de múltiples universidades y laboratorios nacionales. (NC State University,
2014)
InCNTRE-Universidad de Indiana
Centro de educación, investigación, capacitación y desarrollo para la adopción de
OpenFlow y otras tecnologías de red (SDN). A través de iniciativas como el
laboratorio de interoperabilidad SDN. (InCNTRE's SDN Interoperability Lab, 2015)
CoSDN - Cognitive Software Defined Networks-Universidad de Luxerburgo
La investigación y la aplicación CoSDN se basa en los conceptos de gestión y
control de la red autónoma. Tal combinación de SDN con los marcos autónomos y
algoritmos cognitivos es una propuesta muy novedosa. A pesar de que ha habido
contribuciones de investigación importantes en el pasado en relación con estas
áreas mencionadas, no hay actualmente actividades de investigación que intenten
combinar estos conceptos, estas áreas sólo se están investigando de forma
individual. Los resultados serán empujados a los organismos de normalización
como la Open Network Foundation (ONF), quien está a cargo de la definición de
protocolo OpenFlow, y el Instituto Europeo de Normas de Telecomunicaciones
(ETSI) para garantizar la compatibilidad y la facilidad de acceso para aplicaciones
futuras. (CoSDN - Cognitive Software Defined Networks, 2015)
Victoria University of Wellington, New Zealand
El Centro de Investigación tiene como objetivo fomentar la colaboración con la
industria, la academia y los estudiantes, así como la promoción de actividades de
investigación y desarrollo independientes que promueven las SDN. Victoria
University, sigue presente en la investigación SDN en Australia, para fomentar la
colaboración con la industria y el mundo académico y las actividades de apoyo que
promuevan la SDN. (Web Home Groups SDN Victoria University, 2015)
19
GITA: Grupo de investigación en Telecomunicaciones Aplicadas-Universidad
de Antioquia
Proyecto Redes definidas por software (SDN) como habilitador de tecnologías de
redes inteligentes para el sector energía eléctrica. (Grupo de Investigacion de la
Universidad de Antiquia, 2015)
20
7. ANTECEDENTES
En la actualidad Mininet no cuenta con la implementación de un generador de
topologías aleatorias, razón por la cual da mayor motivación para realizar este
proyecto. A continuación se cita un proyecto desarrollado en Mininet y algunos de
los generadores de topologías existentes.
Marco Canini (2013) The Frenetic Proyect es una plataforma de controladores
SDN de código abierto. Crearon topologías de red personalizadas en Mininet (Entre
ellas Waxman) proyecto ejecutado desde la línea de comando. (Git Hub, 2013)
Adelstein, Hosch, Richard, & Schwiebert (1988) Bessie permite la generación de
topologías de red tanto interactivo como comandos, asignando nodos de
multidifusión3. Bessie genera redes mediante la colocación de puntos al azar en una
rejilla de dos dimensiones y luego utiliza funciones de probabilidad para determinar
qué nodos están conectados. La conectividad puede ser limitada por grado de nodo
y la distancia nodo
Brite Boston University representative Internet Topology Generator Brite fue
diseñado para ser un generador de topología flexible, no se limita a cualquier forma
particular de la generación de topologías. Como tal, soporta múltiples modelos de
generación.
Quoitin & Lepropre IGen no se basa en métodos probabilísticos para generar
topologías de red. Dado que las redes reales son el resultado de un diseño de red
cuidadoso.
Magoni D. (2002) Nem no tiene interfaz de usuario, pero funciona con un archivo
de proceso. Cada línea contiene uno o más instrucciones para ser ejecutadas en
una red. Analiza la topología de las redes y Genera redes aleatorias.
3
Multidifusión: envío de la información en múltiples redes a múltiples destinos simultáneamente
21
7.2 MARCO CONCEPTUAL
Esta sección contiene los conceptos, definiciones e hipótesis que fueron
consultados a lo largo del proceso de desarrollo y fueron indispensables para
alcanzar los objetivos propuestos. Incluye la conceptualización sobre el Emulador
de red Mininet y API4, lenguaje de programación Python, Protocolo Open Flow,
Conceptos sobre Redes Definidas por Software, Generadores de Topologías y
Teoría de Grafos Aleatorios (Waxman).
La arquitectura actual es esencialmente basada en conceptos que nacieron en la
década de 1950. A partir de ahí, diversos protocolos y componentes fueron
agregados, de acuerdo a las necesidades que surgieron a lo largo del tiempo. Esa
arquitectura de redes, a pesar de atender a las necesidades actuales, es compleja,
y de cierta manera, poco flexible para continuar evolucionando a la velocidad del
surgimiento de nuevas aplicaciones que imaginamos para un futuro próximo. En
otras palabras, a pesar de que la arquitectura de redes actual es bastante resistente,
aparentemente, no es lo suficientemente escalable para las futuras necesidades.
Como respuesta a este desafío, diversos involucrados del sector de
telecomunicaciones y tecnología de la información, como fabricantes,
investigadores, empezaron a trabajar en una nueva arquitectura de redes, basada
en patrones abiertos, significativamente menos complejos, más flexible, más
eficiente y potencialmente más baratos. El resultado de ese trabajo es lo que
llamamos Redes Definidas por Software. (Bogdan Ciubotaru, 2013)
7.2.1 SDN
El objetivo de las SDN no es otro que armar a los administradores con
herramientas centralizadas de programación, virtualización y monitorización de
la situación en tiempo real para que las redes se puedan adaptar de forma
eficiente a las necesidades concretas de cada momento, lo que promete acelerar
la transformación de los datacenters hacia una nueva generación más escalable,
automatizar recursos, simplificar tareas y, en definitiva, marcar un antes y un
después en el terreno del networking y las comunicaciones. Con SDN el
procesamiento de paquetes ya no deriva de una serie de ficheros de configuración
estáticos en cada uno de sus miles de nodos,
sino
de
una organización
puramente dinámica a través de una capa de software que virtualiza la red y
la independiza de la infraestructura física subyacente. (Vargas, 2013)
4
Application Programming Interface
22
“Aunque la historia de SDN no ha hecho más que empezar, vemos claramente
cuatro etapas en el futuro.
Automatización de redes. en la actualidad, el control de software de nuestras
redes se realiza en la propia empresa y; con frecuencia, por medios
rudimentarios. Solo si liberamos el código fuente de las interfaces de
programación de aplicaciones (API), empezaremos a conseguir la agilidad que
necesitamos.
Virtualización de redes. cuando dispongamos de la automatización básica,
podrá iniciarse realmente el proceso de separación de la capa 2/3 de la red y la
capa física Aunque esta tecnología todavía está tomando cuerpo, vemos mucho
potencial en los controladores basados en software que utilizan OpenFIow, el
nuevo protocolo SDN para programar conmutadores virtuales en los
hipervisores de software tecnología que se suele denominar "de superposición".
Ampliación de SDN a las redes WAN no solo los Data Centres conseguirán
ventajas, ya que nuestras redes WAN pueden controlarse también mediante
SDN.
Las auténticas redes definidas por software en definitiva, el objetivo tiene que
ser disponer de una capa física simplificada que solo funcione con OpenFlow y
que cuente con API estandarizadas para optimizar la forma en que consumimos
los recursos de la red. Mientras que los operadores y sus clientes solo pueden
salir ganando, los proveedores se muestran recelosos, por lo que tenemos que
asumir que ofrecerán cierta resistencia y que tendremos que esforzarnos para
superarla”. (SRL, 2015)
La figura siguiente representa la arquitectura lógica de las redes definidas por
software, en donde la inteligencia de la red es lógicamente los controladores de las
SDN que mantienen una visión global de la red. Con SDN, empresas y operadores
pueden tomar el control sobre toda la red desde un único punto lógico, lo que
simplifica en gran medida el diseño de la red. (Vargas, 2013)
23
Ilustración 1. Arquitectura lógica de las redes definidas por software
Fuente:
https://www.academia.edu/5730624/Emulaci%C3%B3n_de_una_red_definida_por
_software_utilizando_MiniNet
Estos son los seis principios de las SDN y los correspondientes beneficios que
ofrecen a los clientes:
Separan de forma eficiente el software de red en cuatro niveles
(planos): administración, servicios, control y reenvío.
Esto ofrece el apoyo estructural necesario para optimizar cada plano
dentro de la red.
Centralizan los aspectos necesarios de los planos de administración,
servicios y control para simplificar el diseño de red y para reducir los
costes operativos.
Utilizan la nube para una implementación flexible y con una escala
adaptable, que permite una estructura de precios basada en el uso con
el fin de reducir el tiempo de servicio y establecer una correlación entre
costes/valor.
Crean una plataforma para las aplicaciones de red, los servicios y la
integración en los sistemas de administración, lo que permite el
desarrollo de nuevas soluciones de negocio.
24
Permiten una estandarización de los protocolos, lo que hace
posible disponer de asistencia inter-operativa y heterogénea entre
proveedores, y que da lugar a la posibilidad de elección y de reducción
del coste.
Aplican c o n u n a amplia perspectiva los principios de las SDN a
todos los servicios de red, incluidos los de seguridad. Esto abarca
desde el centro de datos y el campus empresarial hasta las redes
móviles e inalámbricas utilizadas por los proveedores de servicio.
(Vargas, 2013)
Dentro de cada dispositivo de red y de seguridad (conmutadores, enrutadores y
firewall), es posible separar el software en cuatro niveles o planos. A medida
que nos movemos hacia las SDN, es necesario diferenciarlos y separarlos
con claridad.
Se trata de algo esencial para el desarrollo de la siguiente generación de redes
altamente escalables, por tal motivo; se presentan cuatro capas que representarían
el plano de red de una SDN:
1. Forwarding. Se encarga del envío de paquetes en la red, la cual está
optimizado para mover los datos lo más rápido posible, esta capa puede
implementarse en el software, aunque suele desarrollarse sobre circuitos
integrados específicos para aplicaciones (ASIC), que están diseñados para
este propósito.
2. Control. Si pensamos en el plano de forwarding como en los músculos
de la red, el control sería el cerebro. El plano de control analiza la
topología de red y toma decisiones sobre el destino del flujo de la red.
3. Servicios. Algunas redes requieren un mayor procesamiento, para eso se
tiene la capa de servicios, pero no todas los equipos cuentan con esta capa,
como por ejemplo los conmutadores. Sin embargo, en muchos enrutadores y
firewalls, el plano de servicios se encarga de la toma de decisiones y de llevar
a cabo las operaciones complejas con los datos de red
4. Administración. Proporciona las instrucciones básicas sobre cómo debe
interactuar el dispositivo de red con el resto de esta. (Velasquez, 2015)
25
7.2.2 OpenFlow
Openflow es un protocolo de comunicaciones diseñado para dirigir el manejo y
enrutamiento del tráfico en una red conmutada, hasta la fecha los switches decidían
hacia donde llevar el tráfico de manera individual y en base al firmware de cada
uno de ellos, eran dependiente del fabricante y dispositivo, con OpenFlow esa
decisión dejara de ser tomada de manera individual por cada switch y pasará
a estar controlada por una fuente de inteligencia externa.
OpenFlow facilita el acceso a dispositivos de red para la programación simplificada
mediante una interfaz estándar. La facilidad a la hora de programar permite
configurar una capa de control solvente para poder centralizar la inteligencia de la
red y brindar esa capacidad de programación tan pregonada por la tecnología SDN
(Hewlett-Packard, 2014). (Vargas, 2013)
OpenFlow necesita de 3 elementos:
1.
Tablas de flujos en los nodos de conmutación
2.
Un controlador
3.
Un protocolo OpenFlow para que el controlador se comunique con los nodos.
(Park &Baack, 2012).
Los switches consultaran sus tablas de flujo antes de hacer el forwarding del tráfico
y lo realizarán conforme a ellas. Si se da la circunstancia de no saber qué hacer
con el tráfico, preguntaran al controlador y este les dirá que hacer, lo que la
convertirá en una red gestionada de manera centralizada.
Switch Openflow
Los switch openflow se los pueden dividir en tres partes, tal cual como se lo observa
en la figura siguiente, las tablas de flujo, la seguridad del canal y por último el
protocolo openflow.
26
Ilustración 2 Switch Openflow
Fuente: http://yuba.stanford.edu/cs244wiki/index.php/Overview
Las tablas de flujo indican a los switch como deben proceder los paquetes a través
de la red. La seguridad permite conectar a los switch con dispositivos remotos
y el protocolo openflow que es un estándar de comunicación abierta entre los
controladores y el switch.
Los flujos se determinan mediante la combinación de una tupla de 9 elementos que
son parte de los encabezados de las capas 2, 3 y 4 del modelo OSI y son:
1.
2.
3.
4.
5.
6.
7.
8.
9.
Puerto de entrada del conmutador
Dirección fuente MAC
Dirección destino MAC
Tipo Ethernet
VLAN
Dirección IP origen
Dirección IP destino
Puerto TCP/UDP origen
Puerto TCP/UDP destino
Una vez que el switch recibe un paquete, se realizan las funciones mostradas en
la siguiente imagen, inicialmente el switch recibe el paquete, luego revisa las tablas
de flujo y si la dirección se encuentra en las tablas envía el paquete, caso contrario
se lo envía al controlador y este se hace responsable de indicarle al switch que
debe hacer con el mismo. (Vargas, 2013)
27
Ilustración 3. Funciones de Switch
Fuente:
https://www.academia.edu/5730624/Emulaci%C3%B3n_de_una_red_definida_por
_software_utilizando_MiniNet
Protocolo Openflow
El protocolo openflow permite la comunicación entre el switch y el controlador. Los
switches deben ser capaces de establecer comunicación con los controladores,
usando una dirección IP y puerto especificado por el usuario. Si el switch conoce la
dirección del controlador éste inicia una conexión TCP estándar con el controlador.
Cuando una conexión es establecida por primera vez, cada dispositivo conectado
debe enviar mensajes de HELLO con la versión más alta soportada por el
protocolo para él envió, aquellos que reciben los mensajes deben tener una
versión igual o inferior para poder realizar una conexión, caso contrario se envía
un mensaje de ERROR y se termina la conexión . (Vargas, 2013)
Controladores
Los controladores se encargan de centralizar y transmitir la información a la red
manteniendo un paso distribuido a través de los switch y routers. Estos
28
controladores en la red van ubicados dependiendo de cómo estén los switch
conectados, se podrían identificar dos formas de configuración, una de ellas es que
debería haber un controlador centralizado para que administre y configure todos
los dispositivos de la red y la otra que los controladores se repartan de manera
distribuida, es decir, un controlador para cada conjunto de switch.
El objetivo de un controlador es redirigir ICMP 5 o paquetes de Ethernet enviados
entre los dispositivos finales sin importar el tipo de controlador que se tenga,
pero si es importante saber cómo la red debe tomar estas decisiones, los posibles
modos de operación de un controlador son los siguientes:
5
6
Centralizado. Solo se necesita un controlador para manejar los switch, es
decir; un solo controlador maneja todos los dispositivos de la red.
Por flujo. Cada entrada es configurada por el controlador y así mismo, las
tablas contienen las nuevas líneas del flujo.
Reactivos. El controlador está diseñado inicialmente para no hacer nada
hasta que reciba un mensaje, sean estos: Solicitudes de ping, mensajes
RST6 o introducir una regla en las tablas de flujo para así ser enviados al
destino. A este método se lo conoce como reactivo, porque una vez que
se procese el mensaje, el controlador usará una regla específica para
enviar el paquete al destino.
Proactivos. El controlador anticipa el mensaje de respuesta, el mensaje
Ping Responder, y finalmente antes de recibir el mensaje Ping Reply, el
controlador inserta la regla en las tablas de flujo del switch. Entonces,
cuando el switch recibe el mensaje Ping Reply, el switch ya tiene la regla
para envía el paquete. (Vargas, 2013)
Internet Control Message Protocol
Ping Request Message
29
Esquema básico de un controlador en la red:
Ilustración 4. Esquema básico de un controlador de red
Fuente:
https://www.academia.edu/5730624/Emulaci%C3%B3n_de_una_red_definida_por
_software_utilizando_MiniNet
Si el switch no sabe qué acción realizar con un paquete en específico, lo pasa al
controlador. El controlador recibirá el paquete y revisara si este es un paquete
Ethernet, hay dos casos posibles:
Si el paquete no es uno de Ethernet, el controlador lo descarta.
Si el paquete es Ethernet, el controlador analizara las cabeceras del
paquete para obtener la dirección de destino (dirección MAC y dirección
IP). Después, el controlador inserta las reglas necesarias en los switch para
que pueda ser enrutado al destino.
30
Diagrama de flujo de las funciones de un Controlador
Ilustración 5. Diagrama de flujo de las funciones de un controlador
Fuente:
https://www.academia.edu/5730624/Emulaci%C3%B3n_de_una_red_definida_por
_software_utilizando_MiniNet
7.2.3 Mininet
Es un emulador de red que ejecuta una colección de dispositivos finales, switches,
routers y enlaces en un solo núcleo de Linux, utilizando la virtualización y
permitiendo así la creación de una red completa, ejecutándose a través de un
mismo kernel.
En resumen, los dispositivos virtuales de Mininet, conmutadores, enlaces y los
controladores se crean utilizando software en lugar de hardware, en su mayor
parte el comportamiento es similar a los elementos de hardware. La eficiencia de
Mininet permite que con un solo comando se ejecute la red. (Vargas, 2013)
Ejemplo:
31
Ilustración 6. Dispositivo virtual de Mininet
Fuente: http://mininet.org/
Ventajas de Mininet
Mininet presenta un sin número de ventajas al querer simular una red, la cual se
presentan a continuación: (Vargas, 2013)
Es rápido – la puesta en marcha de una red simple tarda sólo unos
segundos. Esto significa que el bucle de gestión edit-debug puede ser muy
rápido.
Puede crear topologías personalizadas: un solo switch, grandes
topologías tipo Internet, la red troncal de Stanford, un centro de datos, o
cualquier otra cosa de redes.
Ejecutar programas reales: cualquier cosa que se ejecute en Linux está
disponible para que funcione, desde los servidores de Internet hasta
las herramientas de TCP para el monitoreo de paquetes.
Personalizar el reenvío de paquetes: los switch de MiniNet son
programables usando el protocolo OpenFlow, lo que significa que los diseños
de red se pueden transferir fácilmente a los switches OpenFlow.
Puede ejecutar MiniNet en su computadora portátil, en un servidor, en una
máquina virtual, en una máquina Linux nativo (MiniNet se incluye con Ubuntu
12.10), o en la nube (por ejemplo, Amazon EC2).
Puede compartir y replicar los resultados: cualquiera con una
computadora puede ejecutar el código una vez que se han instalado los
paquetes necesarios para su funcionamiento.
Se puede crear y ejecutar experimentos MiniNet escribiendo simples
(o complejos de ser necesario) scripts de Python.
32
Limitaciones
Correr en un solo sistema es conveniente, pero también impone límites de
recursos: si su servidor tiene 3 GHz de CPU y cambia su tráfico simulado de Gbps 7,
tendrán que ser equilibradas y compartidas entre los hosts virtuales y
switches. (Vargas, 2013)
Mininet utiliza un solo núcleo de Linux para todos los hosts virtuales, lo que
significa que no se puede ejecutar el software que depende de BSD,
Windows, u otros núcleos del sistema operativo. (Aunque se puede
conectar máquinas virtuales a Mininet.)
Mininet no escribirá su controlador OpenFlow para usted, si usted
necesita enrutamiento personalizado o el comportamiento de conmutación,
usted tendrá que encontrar o desarrollar un controlador con las
características que usted requiere.
Actualmente Mininet no hace NAT8 fuera de la caja. Esto significa que
sus máquinas virtuales se pueden aislar de la red LAN9 de forma
predeterminada, lo que suele ser bueno, pero significa que sus anfitriones
no pueden hablar directamente a Internet a menos que proporcione un
medio para que lo hagan. (el ejemplo nat.py muestra cómo configurar
hosts Mininet para la conectividad
externa,
y
los ejemplos
hwintf.py muestran cómo agregar una interfaz física para Mininet.).
Todos los hosts Mininet comparten el sistema de archivos y el espacio
PID10, lo que significa que es posible que tenga que tener cuidado si se está
ejecutando demonios que requieren de configuración en /etc.
A diferencia de un simulador, Mininet no tiene una fuerte noción de tiempo
virtual, lo que significa que las medidas de temporización se basarán en
tiempo real, y que los resultados serán en tiempo real (por ejemplo, redes a
100 Gbps) no pueden ser fácilmente emuladas.
7
Gigabit per second
Network Address Translation
9
Local Area Network
10
Proportional–Integral–Derivative
8
33
Interactuar con los Host y Switch
Puede interactuar con Mininet, iniciando una topología mínima utilizando
el comando: sudo mn, la red predeterminada que se cargará consta de un
controlador que administra un switch conectado a dos host. A continuación se
presentan los comandos básicos:
Help: Muestra los comandos de Mininet. Nodes: Muestra los nodos de la red
Net: Muestra los enlaces que se tiene en la red.
Ifconfig-a: Muestra la configuración IP del dispositivo que se desea consultar,
puede ser un host o switch. El uso es de la siguiente manera: h1 ifconfiga, donde h1 representa el host 1 en la red.
Ps-a: Muestra en pantalla los procesos que se están ejecutando en la máquina,
la forma de usarlo es: h1 ps-a, donde h1 es el host 1 en la red. Se debe
recordar que los procesos a mostrar serán los mismos tanto en los host como en
los switch, debido a que se está virtualizando la red más no se tiene máquinas
individuales.
Ping -c: Permite hacer ping entre los dispositivos de la red, la manera de uso
es la siguiente: h1 ping-c 1 h2. El host 1 está haciendo ping al host 2, pero solo
le está enviando un mensaje, la cantidad de mensajes puede ser configurada
indicando el número de mensajes después del comando ping -c. (Vargas, 2013)
Topología de cierta simulación
En el gráfico siguiente se puede observar claramente una estructura con un
controlador centralizado, encargado de reenviar los paquetes a los switch y estos a
su vez transmitirlos a los dispositivos finales.
34
Topología de red simulada
Ilustración 7. Topologia de Red simulada
Fuente:http://es.slideshare.net/wavelasq/emulacin-de-una-red-definida-porsoftware-utilizando-mininet
La ilustración anterior muestra la siguiente topología: 12 host,3 switch y 1
controlador. Los host están repartidos en cuatro por cada switch, switch 1 (s5) tiene
los host (h1, h2, h3, h4), switch 2 (s16) tiene los host (h14, h15, h13, h12),
switch 3 (s23) tiene los host (h24, h25, h26, h27) y controlador administra los
tres switch.
Primero se importan las librerías de Mininet para usar la API, luego se define
una topología, es decir; instanciamos un objeto “Mininet”. Se crean los nodos,
todos los host con su dirección IP, los switch y el controlador; luego se agregan
las relaciones entre ellos y finalmente se procede a ejecutar el controlador.
Al ejecutar el archivo MininetTopologia.sh se crean en la maquina las interfaces
virtuales y al mismo tiempo compila el código de la simulación, en la ilustracion
siguiente se muestra la ejecución del comando net: (Vargas, 2013)
35
Ilustración 8. Ejemplo simulacion Mininet
Fuente:
https://www.academia.edu/5730624/Emulaci%C3%B3n_de_una_red_definida_por
_software_utilizando_MiniNet
Mininet ofrece en su sitio web oficial (www.Mininet.org) información suficiente para
la instalación del software y los primeros acercamientos a la herramienta, además
para que, con base en ella, puedan crearse importantes desarrollos en cuenta a la
simulación de Redes Definidas por Software se refiere, inclusive redes que utilicen
el protocolo IPv6.
API Mininet
A lo largo de esta introducción, que ha estado expuesto a una serie de clases de
Python que comprenden la API de Mininet, incluyendo clases como Topo, Mininet,
Host, Switch, Link y sus subclases. Es conveniente dividir estas clases en los niveles
(o capas), ya que en general las API de alto nivel se construyen utilizando las API
de nivel inferior.
La API de Mininet está construida en tres niveles principales:
API de bajo nivel: La API de bajo nivel consta de las clases de nodo base y
de enlace (tales como Host, Switch, Link y sus subclases) que en realidad
se pueden crear instancias de forma individual y se utiliza para crear una red,
pero es un poco difícil de manejar.
36
API de nivel medio: La API de nivel medio añade el Mininet objeto que sirve
como contenedor para los nodos y enlaces. Proporciona una serie de
métodos (como addHost (), addSwitch (), y addLink ()) para agregar nodos y
enlaces a una red, así como la red de configuración, puesta en marcha y
parada (en particular, start () y stop ().
API de alto nivel: La API de alto nivel añade una abstracción de topología. La
clase Topo ofrece la posibilidad de crear plantillas de topologías reutilizables
parametrizados. Estas plantillas se pueden pasar a la mn de comandos (a
través de la --custom opción) y se utilizan desde la línea de comandos.
En general cuando se quiere controlar los nodos y conmutadores directamente, se
utiliza la API de bajo nivel. Cuando se inicia o detenie una red, por lo general utiliza
la API de nivel medio (en particular el Mininet clase.)
Las cosas se vuelven interesantes cuando se comienza la creación de redes
completas,las redes completas pueden ser creadas usando cualquiera de los
niveles de API (como se ve en los ejemplos), pero en general se pueden elegir tanto
la API de nivel medio (por ejemplo Mininet.add * ()) como la API de alto
nivel (Topo. añadir * ()) para crear las redes. (GitHub Mininet, s.f.)
Estos son ejemplos de la creación de redes de uso de cada nivel de la API:
API de bajo nivel: nodos y enlaces
Ilustración 9. Nodos y enlaces
Fuente: https://github.com/mininet/mininet/wiki/Introduction-to-Mininet#api
37
API de nivel medio: Objeto de Red
Ilustración 10. Objeto de red
Fuente: https://github.com/mininet/mininet/wiki/Introduction-to-Mininet#api
API de alto nivel: las plantillas de topología
Ilustración 11. Plantilla de topología
Fuente: https://github.com/mininet/mininet/wiki/Introduction-to-Mininet#api
38
7.2.4 Modelo de Grafo Aleatorio
Modelo Waxman
A partir de observaciones efectuadas sobre Internet, Waxman formuló dos hipótesis
respecto a cómo estaban conectados los routers en la red. En su trabajo sostuvo
que:
Los routers de Internet se encuentran distribuidos geográficamente y que
esta distribución incide en la forma en que están conectados.
Como resultado de un proceso de optimización de recursos, la existencia de
conexiones es más probable entre routers cercanos que entre routers
distantes. A partir de estas hipótesis y tomando como base el modelo Erdos
Renyi, Waxman realizó una modificación para que la probabilidad de
conexión de los nodos fuera dependiente de la distancia entre los
mismos.(Waxman, 1988)
Los grafos Waxman, han sido introducidos como una en particular la clase de grafos
aleatorios para modelar topologías de red y tiene el propósito de evaluar los
algoritmos de enrutamiento(Waxman, 1988).
Los nodos se distribuyen de manera uniforme sobre un área rectangular, y los
enlaces se añaden entre el los nodos a través de un mecanismo aleatorio (la
probabilidad de que dos nodos están conectados directamente disminuye
exponencialmente a medida que aumenta su distancia euclidiana). Los grafos
Waxman caen en la clase general de modelos espaciales, donde las propiedades
de conectividad de la gráfica están directamente relacionados con las relaciones
espaciales entre los routers (es decir, sus distancias). A pesar del número de los
modelos de la competencia, los gráficos Waxman han sido ampliamente aceptados
como un modelo de topología para la red intra-dominio y empleado en muchos
estudios de enrutamiento de rendimiento(Naldi, 2005).
En la formulación original de Waxman, los gráficos tienen un número N
predeterminado de nodos, que son distribuidos uniformemente sobre una cuadrícula
de coordenadas rectangular, esto significa que cada nodo tiene coordenadas
enteras, mientras que si se considera el caso más general, donde un nodo puede
estar en cualquier lugar dentro del área rectangular.
39
La probabilidad de que existe un vínculo directo entre los nodos genéricos u y v es
relacionado con la distancia euclidiana d (u, v) entre ellos por la expresión:
Donde L es la distancia máxima entre dos nodos, y 𝜶 y 𝜷 son dos parámetros en el
rango (0,1). Los valores más altos de 𝜷 resultan en gráficos con mayor densidad
de enlaces, mientras que los pequeños valores de 𝜶 tienen un aumento de la
densidad de enlaces cortos en relación con los más largos (en algunas
formulaciones posteriores del modelo del posiciones y roles, de 𝜶 𝒚 𝜷 se
intercambian. (Waxman, 1988)
Dado que la probabilidad de que exista un vínculo entre dos nodos depende de su
distancia, y esta es una variable aleatoria, el primer paso es derivar la función de
densidad de probabilidad de la distancia entre dos nodos. Se considera el caso
general de un rectángulo que contiene nuestros nodos, cuya relación de lado
(relación entre el más pequeño y el mayor de los lados del rectángulo) se indica por
𝒓 . Lo que interesa es la distancia normalizada 𝑫, es decir, la distancia dividida por
la longitud de la diagonal del rectángulo, ya que la expresión enlace de probabilidad
puede ser reformulada como: (Waxman, 1988)
Ilustración 12. Modelo de Waxman
Fuente: https://www.cs.purdue.edu/homes/dgleich/demos/erdos_renyi/
40
Modelo Erdos - Renyg
El más sencillo de los modelos de grafos aleatorios fue propuesto por Erdos - Renyig
hacia 1960. Este modelo considera un grafo con n vértices, en el que la probabilidad
de que dos vértices distintos tomados al azar estén conectados es fija e igual a p.
Los grafos aleatorios Erdos-Renyi (ER) Gnp presentan las siguientes propiedades:
El
tamaño
del
grafo
sigue
una
distribución
binomial:
.
𝒏
En donde 𝑵 = (𝟐)
La esperanza del tamaño del grafo es
El grado de los vértices sigue
una
distribución
.
La esperanza del grado de un vértice es
El coeficiente de agrupamiento esperado de un vértice es
La concordancia por grados es asintótica a 0 para 𝒏 → ∞
El diámetro es asintótico a ln n= ln(pn) para 𝒏 → ∞
El grafo es conexo con alta probabilidad.
Ilustración 13. Modelo Erdos-Renyi.
Fuente: (Beiró, 2010)
41
binomial:
La arista-conectividad es asintótica a a (n - 1) p para 𝒏 → ∞
Es habitual estudiar el comportamiento de los grafos Erdos-Renyi cuando 𝒏 → ∞
manteniendo np constante, de manera de conservar el grado medio de los vértices.
Bajo esta restricción, con 𝒏 → ∞ se cumple que:
La distribución de grados de los vértices converge a una Poisson con media
np.
El coeficiente de agrupamiento de los vértices y global es asintótico a 0.
El grafo es no conexo (el diámetro es infinito).
Los grafos Erdos-Renyi no son adecuados para modelar redes complejas por tener
una distribución de grados con caída exponencial (en lugar de una cola larga) y un
coeficiente de agrupamiento pequeño, y por la ausencia de correlaciones que se
manifiesta, por ejemplo, en una concordancia por grados cercana a cero. (Erdos &
Renyi, 1958)
Modelo Barabasi-Albert
En su trabajo, Barabasi y Albert descubrieron la presencia de leyes de escala en las
distribuciones de los grados de muchas redes complejas, y la ejemplificaron con la
Web, una red de citaciones científicas y la red de distribución de energía de los
Estados Unidos, entre otras. Asimismo, mostraron que los modelos de redes
conocidos hasta ese momento, como el Erdos-Renyi y el Watts-Strogatz, no
lograban capturar esta naturaleza libre de escala. Propusieron entonces un nuevo
modelo con el objetivo de obtener leyes de potencia en la distribuciones de grados,
partiendo de dos hipótesis: el crecimiento de la red y el mecanismo de acoplamiento
preferencial (preferential attachment).
El modelo Barabasi-Albert parte de una red formada por una cantidad m0 de vértices
conectados, que llamaremos G0, y evoluciona en forma discreta en el tiempo
incorporando un nuevo vértice en cada instante. En el instante t, dado el grafo
𝑮𝒕−𝟏 = 𝑽𝒕−𝟏, 𝑬𝒕−𝟏 se incorpora un vértice vt para obtener un grafo Gt. Al ser
incorporado, el nuevo vértice se conecta con una cantidad 𝑚 ≤ 𝑚0 de vértices en
𝑽𝒕−𝟏 cada uno de los cuales se elije con una probabilidad p(vj) proporcional a su
grado:
42
A partir de esta regla y luego de un tiempo suficiente, la distribución de grados
alcanza un estado estacionario libre de escala. Este comportamiento fue mostrado
empíricamente por Barabasi y Albert y luego probado formalmente por enfoques de
campo medio basados en ecuaciones cinéticas (rate equations). (Beiró, 2010)
Ilustración 14. Modelo Barabasi-Albert
Fuente: (Beiró, 2010)
El modelo Watts-Strogatz
Watts y Strogatz se plantearon entonces el problema de reproducir esta situación
en un modelo de red con grado medio fijo. En el modelo Erdos-Renyi hemos visto
que esto no es posible, dado que manteniendo el producto np constante, con n
suficientemente grande se obtiene una red disconexa y con coeficiente de
agrupamiento tendiendo a cero.
Los autores compararon esta situación con el caso de determinados reticulados, en
los que el coeficiente de agrupamiento es elevado pero la distancia entre dos nodos
puede ser muy grande. Buscando un punto intermedio, propusieron un modelo que
parte de una estructura de tipo anillo en la que los nodos se conectan con sus 2*k
vecinos más cercanos en el anillo (de manera de obtener un alto coeficiente de
agrupamiento) y luego realiza un proceso de recableado en que, con cierta
probabilidad p, las aristas uv se eliminan y se establece una arista uw con algún
nodo w al azar. El procedimiento de recableado no modifica la cantidad de aristas
del grafo, por lo cual se conserva el grado medio.
43
El incremento de la probabilidad p disminuye la distancia promedio pero también el
coeficiente de agrupamiento global. Sin embargo, para una amplia variedad de
valores de p (en el rango 𝒏−𝟏 ≪ 𝒑 ≪ 𝟏) el modelo logra obtener grafos con baja
distancia promedio y coeficiente de agrupamiento elevado.
Los grafos aleatorios obtenidos con el modelo Watts-Strogatz presentan las
siguientes propiedades:
El tamaño del grafo es kn
Para 𝒏 → ∞ 𝒚 𝒑 → 𝟏, la distribución de grados de los vértices converge a una
distribución de Poisson de media k.
En la región 𝒏−𝟏 ≪ 𝒑 ≪ 𝟏 el coeficiente de agrupamiento esperado de un
3(𝑘−1)
vértice es: 2 (2𝑘−1)
En la región 𝒏−𝟏 ≪ 𝒑 ≪ 𝟏 la distancia esperada entre vértices es ln n/ ln k.
Si bien la distribución de los grados en el modelo Watts-Strogatz sigue siendo una
distribución de Poisson, el gran mérito de este modelo es haber sido el primero en
construir redes de mundo pequeño. (Beiró, 2010)
Ilustración 15. Modelo Watts-Strogatz
Fuente: https://es.wikipedia.org/wiki/Modelo_Watts_y_Strogatz
44
7.2.9 Generadores de Topologías
Las herramientas de simulación hoy en día son ampliamente utilizadas para poner
a prueba los protocolos de red. La topología de red es modelada por un grafo no
dirigido donde se modelan los dispositivos de red, nodos y la comunicación entre
ellos. (Magoni & Pansiot, 2002). Un generador de topologías de red reduce
drásticamente el tiempo dedicado por investigador o estudiante para obtener los
modelos de red y ser estudiados. (Inda, Bravo, & Flores, 2009).
El modelado de la topología de Internet es de vital importancia para los
investigadores. Algunos protocolos de red, y en particular los de multidifusión, tienen
actuaciones que dependerán en gran medida de la topología de red. Es por ello que
la topología modelo utilizada para la simulación de los protocolos debe ser lo más
realista posible. (Magoni & Pansiot, 2002)
Un generador de topologías ideal debe permitir el uso y el desarrollo de modelos de
generación que producen representaciones precisas de topologías de Internet. La
siguiente es una lista de características deseables para tales generadores de
topologías.
1. Representatividad. Produce topologías precisas. La precisión debe reflejarse
en tantos aspectos de la topología de Internet real como sea posible (por
ejemplo, estructura jerárquica, grado de distribución de nodos, etc.).
2. La inclusividad. Combina en una sola herramienta las ventajas de la mayoría
de generadores.
3. Flexibilidad. Genera topologías con más de una amplia gama de tamaños.
Restricciones como el número mínimo y máximo de nodos deben evitarse
razonablemente.
4. Eficiencia. Genera grandes topologías (por ejemplo, número de nodos> 100,
000) con CPU razonable y consumo de memoria.
5. Extensibilidad. Proporciona mecanismos que permiten al usuario extender
fácilmente sus capacidades mediante la adición de modelos de nueva
generación.
6. La facilidad de uso. Sigue los principios de uso de interfaces de usuario
estándar. El usuario debe aprender la mecánica de la herramienta de
generación de una sola vez. Para cada modelo de generación incorporada
en la herramienta, sólo debería tener que aprender la funcionalidad asociada
con el nuevo modelo.
45
7. Interoperabilidad. Proporciona interfaces para aplicaciones principales de
simulación y visualización. Debe ser posible generar topologías que pueden
ser procesados por los simuladores ampliamente utilizados.
8. Robustez. No sacrificar robustez en nombre de la eficiencia e incluye
amplias capacidades de detección de errores. (Medina, Lakhina, Matta, &
Byers, 2001)
A continuación se citan algunos generadores de topología:
Bessie
Bessie permite tanto la generación de topologías de red tanto interactivo como
comandos, asignando nodos de multidifusión. Bessie genera redes mediante la
colocación de puntos al azar en una rejilla de dos dimensiones y a continuación,
utiliza funciones de probabilidad para determinar qué nodos están conectados. La
conectividad puede ser limitada por grado de nodo y la distancia nodo. (Adelstein,
Hosch, Richard, & Schwiebert, 1988).
El usuario también puede leer y escribir descripciones de redes como archivos
Bessie, y guardar una imagen gráfica de la red actual. La Figura ilustra la GUI Bessie
básica.
Mientras Bessie se utiliza principalmente en la evaluación de la generación de árbol
de algoritmos multidifusión, se espera que el modelo básico sea útil en otras áreas
de investigación de la red, en particular como se incorporan modelos de red
adicionales. (Adelstein, Hosch, Richard, & Schwiebert, 1988).
46
Ilustración 16. Interfaz de usuario para la versión Bessie
Fuente: (Adelstein, Hosch, Richard, & Schwiebert, 1988)
Un conjunto de parámetros controla la generación de red en Bessie. Entre los
parámetros son los siguientes:
Tamaño total de la red,
El número de redes de satélites y el tamaño medio de una red de satélites.
(Adelstein, Hosch, Richard, & Schwiebert, 1988)
Nem
Nem no tiene interfaz de usuario, pero funciona con un lote de archivo ASCII
llamado archivo de proceso. Cada línea contiene uno o más instrucciones para ser
ejecutadas en una red. Tiene las siguientes características:
1. Convertir archivos de red de un formato a otro
2. Analizar las topologías de las redes
3. Generar redes aleatorias (Magoni D. , 2002)
47
Ilustración 17. NEM
Fuente: (Magoni & Pansiot, 2002)
Brite
Brite fue diseñado para ser un generador de topologías flexible, no se limita
cualquier forma particular de la generación de topologías. Como tal, soporta
múltiples modelos de generación. La figura siguiente representa una vista
esquemática de la estructura de BRITE, está siendo utilizada en la Universidad de
Boston.
Características:
Argumentan que la conectividad y el crecimiento preferencial incrementales
son las razones principales de la ley de distribución de poder de internet
Colocación nodo sesgada
El área se divide en plazas y nodos distribuidos (un nodo está seleccionado
para la columna vertebral)
Cada cuadrado se divide en cuadrados.
Los nodos se distribuyen de manera uniforme entre los cuadrados
Conexiones de red preferencial basado localidad (utiliza la función
probabilística Waxman)
Grado de distribución también se conserva para los nodos (Brite Boston
University representative Internet Topology Generator, 2014)
48
Ilustración 18. Grafica de Brite
Fuente: (Brite Boston University representative Internet Topology Generator,
2014)
IGen
A diferencia de GT-ITM y BRITE, iGen no se basa en métodos probabilísticos para
generar topologías de red. Dado que las redes reales son el resultado de un diseño
de red cuidadosa, iGen implementa diversas heurísticas de diseño de red (Quoitin
& Lepropre, 2010)
Generador de topología de nivel Router
La mayoría de los generadores de topología de Internet utilizan redes
aleatorias.
Topología de Internet es de alta ingeniería, optimizado para los costes y
afectados por las relaciones de negocios entre Sistemas Autónomos.
Diseño de topologías complejas
49
Ilustración 19. Captura de pantalla IGen con una topología entre dominios
Fuente: (Quoitin & Lepropre, 2010).
8. IMPLEMENTACION
GENERADOR DE TOPOLOGÍAS ALEATORIAS (WAXMAN)
El generador de topología aleatoria introducido por Waxman, en el año1988, es un
modelo geográfico para el crecimiento de una red informática. En este modelo los
nodos de la red están distribuidos uniformemente en el plano y los límites se añaden
de acuerdo con las probabilidades que dependen de las distancias entre los
nodos. La probabilidad de tener un borde entre nodos u y v viene dada por la
fórmula:
P (u, v) = ae -d / (BL)
donde 0 <a, b <= 1, d es la distancia de u a v, y L es la distancia máxima entre dos
nodos. Un aumento en el parámetro aumenta la probabilidad de bordes entre los
nodos en el gráfico, mientras que un aumento en B se obtiene una proporción mayor
de los bordes largos a los bordes cortos. (Waxman, 1988)
50
8.1 LIBRERIAS INSTALADAS PARA EJECUTAR LA TOPOLOGIA WAXMAN
Para ejecutar el código que genera la topología de Waxman fueron necesarias
instalar varias dos librerías principales que están enfocadas en los cálculos
científicos y matemáticos, especialmente las orientadas al cálculo matricial, ellas
son:
- Numpy
NumPy es el paquete fundamental para la computación científica con Python, en
especial para el manejo de matrices con N dimensiones, álgebra lineal,
transformaciones de Fourier, y capacidades de números aleatorios
- Scipy
SciPy es una colección de algoritmos matemáticos y funciones de conveniencia
construidas sobre la extensión Numpy de Python. Con SciPy una sesión interactiva
de Python se convierte en un entorno de procesamiento de datos y el sistema de
prototipado rivalizando Sytems como MATLAB, IDL, Octave, R-Lab y SciLab.
Ilustración 20. Librerías importadas
Fuente: Elaboración propia
8.2 DEFINICION DE LA FUNCION
Para escribir el código requerido se eligió Python, que es el lenguaje de
programación ideal ya que Mininet fue desarrollado en este.
Luego de generar el encabezado del documento e importar las librerías requeridas
se procede a definir la función que pide los parámetros para la realización de los
cálculos:
51
Con la palabra reservada “def” se crea la función, para este caso se llamó “waxman”,
seguido y entre paréntesis ingresamos, separadas por coma (,), las variables que
se requieren para recibir los parámetros iniciales. Se asignan unos valores por
defecto para garantizar la ejecución de la función en caso que se omita uno o más
de los valores que deben ser ingresados como parámetros para la ejecución de la
función.
Las variables se definen de forma dinámica; es decir, no se tiene que especificar
cuál es su tipo de antemano, se le asignan valores con el signo igual (=).
Las variables iniciales que reciben los valores para los cálculos son:
lambda que es la intensidad del proceso de Poisson
alpha, que captura el enlace de máxima probabilidad.
Beta, almacena el parámetro para controlar la longitud de los bordes.
Límites, es una tupla que guarda los datos de la región donde se distribuirán
los puntos. Del mismo modo de la función los valores se separan por coma
(,) para identificarlos como valores individuales. Estos valores son
almacenados en su orden en las variables:
o xmin, borde inferior del eje x
o xmax, borde máximo del eje x
o ymin, borde inferior del eje y
o ymax, borde máximo del eje y
Ilustración 21. Definición de la Función Waxman
Fuente: Elaboración propia
8.3 VALIDACIÓN
En la primera versión del script no se tenían establecidas validaciones de ingreso
de datos, por lo que generaba error al ingresar valores no válidos pero sin
determinar la causa.
Se opta por ingresa validaciones básicas para quien genere la topología identifique
con claridad la causa del error. Estas validaciones contemplan los valores
ingresados para las variables _lambda, alpha, beta, que deben estar entre 0 y 1 por
tratarse de una probabilidad, y los valores de xmin, xmax, ymin, ymax
52
Ilustración 22. Validación de ingreso de datos
Fuente: Elaboración propia
8.4 CALCULO DEL ÁREA
Inicialmente se determina el área o espacio geográfico (limites) en el cual estarán
distribuidos los nodos, y que son insumo principal para realizar la colocación de los
puntos. Estos datos son recibidos mediante la tupla de la forma:
Ilustración 23. Tupla Límite
Fuente: Elaboración propia
Se define la nueva variable “área”, la cual almacena el valor del cálculo realizado
con los valores capturados por intermedio de la tupla “límites”. Este valor de
determina mediante el cálculo:
Ilustración 24. Calculo área
Fuente: Elaboración propia
53
8.5 NODOS
En esta implementación el número de nodos se distribuyen con la intensidad
proporcional al área del dominio, siguiendo la distribución de Poisson.
Para identificar esa función fue necesario remitirnos a las librerías de Mininet y
estudiar detenidamente que opción nos servía para este cálculo, ya que la función
sin parámetros genera error.
La distribución de Poisson se encontró dentro de las funciones estadísticas de
Mininet, y dentro de Poisson el método forma “rvs” que genera una variable
aleatoria discreta. Se eligió el método “rvs” porque garantiza que el número de
valores sea finito.
Para determinar la cantidad de nodos se ejecuta la función poisson.rvs con los
parámetros _lamba * área (variables anteriormente descritas).
Ilustración 25. Calculo de nodos
Fuente: Elaboración propia
8.6 DISTRIBUCIÓN DE NODOS
Obtenido el número de puntos se debe generar la distribución uniforme dentro del
área calculada. Esto requirió nuevamente buscar en la documentación disponible
para determinar la mejor opción, en inglés principalmente, los registros en español
son pocos y pobres de contenido.
Inicialmente se usó la librería random, pero no permitió el adecuado manejo de los
parámetros porque que se requiere como resultado una matriz. Luego de esta
prueba y después de ampliar la búsqueda se halló la librería Numpy, que es el
paquete de computación científica de Python y que está especialmente orientado al
manejo de matrices.
Una vez instalada la librería Numpy se realizó el cambio de random a
numpy.random.random pero no fue exitoso, no permite el ingreso de parámetros;
debido a esto se continuó consultando las diferentes rutinas de Numpy, fue un largo
proceso de documentación y pruebas, hasta encontrar el parámetro “uniform” que
nos permitió a parte de ingresar los parámetros, conserva la estructura uniforme de
la matriz que nos cambiaba numpy.random.
54
Así los nodos se distribuyen de manera pareja en la red aprovechando la función
numpy.random.uniform, el 2 indica el tamaño de la matriz, en la imagen a
continuación se muestra la sintaxis:
Ilustración 26. Distribución de nodos
Fuente: Elaboración propia
Con este dato se realiza la distribución de los puntos para los ejes X y Y.
Ilustración 27. Distribución en los ejes X y Y
Fuente: Elaboración propia
8.7 DEFINICIÓN DE DISTANCIAS
Una red es un grafo aleatorio, el gráfico está representado por un vector que
contiene las coordenadas de los nodos y la matriz de adyacencia de la gráfica.
El elemento en la posición (i, j) es igual a 1 si los puntos i y j en el vector de
coordenadas están conectados.
Para generar una red aleatoria, se tiene que crear un vector con las coordenadas
de los nodos, replicar el vector que contiene las coordenadas de los nodos N veces
y almacenar en una matriz todas las posibles distancias (d (i, j)).
Nuevamente se remite a la documentación de Python, más encaminados con la
experiencia del punto anterior; después de una larga búsqueda se encuentra el
parámetro “tile”.
Con el parámetro “tile” se replican las coordenadas del vector en dos nuevas
variables (x_rep y y_rep) para almacenar los valores no repetidos y a partir de estos
generar una nueva matriz.
55
Ilustración 28. Coordenadas del Vector
Fuente: Elaboración propia
Usando la clase coo_matrix de la librería numpy se genera la matriz en formato de
coordenadas usando la forma:
coo_matrix ((datos, (i, j)), [forma = (M, N)]) donde:
Datos [:] las entradas de la matriz, en cualquier orden
i [:] los índices de fila de las entradas de la matriz
j [:] los índices de columna de las entradas de la matriz.
Ilustración 29. Matriz de distribución
Fuente: Elaboración propia
8.8 DEFINICIÓN DE PROBABILIDADES
La clase Triu, importada de la librería Numpy garantiza el operar con valores
diferentes a cero (0). Dado que la matriz de distancias es simétrica con ceros en la
diagonal, se declaran como triangular superior y matriz escasa. Esto permite
mantener en la memoria sólo los elementos distintos de cero por encima de la
diagonal principal.
Antes de llegar a triu, se prueba con la clase “power” en el camino de aprendizaje
de Python, pero no cumplía con el resultado esperado por lo que rápidamente se
descartó y se continuó con la búsqueda la clase que requiere.
Una vez obtenida la matriz de distribución (dist_matr) se calcula la matriz de
probabilidades:
56
Ilustración 30. Matriz de probabilidades
Fuente: Elaboración propia
Ahora se procede a generar la matriz de adyacencia de acuerdo a las probabilidades
calculadas en el paso anterior.
Se utiliza el argumento “astype” para redondear los valores de la matriz a valores
enteros para optimizar la asignación de los valores en el plano que se distribuyen
aleatoriamente.
Se toman los valores enteros de la anterior matriz (matriz de probabilidades) para
calcular la matriz de adyacencia, validando que estén dentro de la matriz.
Ilustración 31. Matriz de adyacencia
Fuente: Elaboración propia
8.9 ASIGNACIÓN DE HOST A LOS N NODOS
A partir de esta instancia se inicia un nuevo proceso de aprendizaje, cambiando de
Python para sumergirse en la API de Mininet. Se continúa con el reto de la
documentación en inglés, y se comienzan a asimilar nuevos conceptos, términos y
definiciones propios de esta plataforma. Tras muchas horas de lectura en especial
desde la página oficial de Mininet, se obtiene la información básica para iniciar a
aplicar su verdadero poder como emulador.
Importación de librerías de Mininet.
CLI permite controlar y administrar toda la red virtual desde una única consola,
ejemplo: hacer ping.
57
TOPO tiene como objetos propios los switches, host, links entre otros permitiendo
así asignar con agilidad todos los elementos que requiramos.
IRANGE guarda resultados para su uso posterior.
La clase se crea con la palabra reversada “class” y se define como tipo “topo” para
que Mininet pueda reconocerla y ejecutarla como tal.
Se invoca el parámetro “self” para asociarla a la librería topo, y “k” esa una variable
que almacena la cantidad de nodos generados.
Ilustración 32.Definición de la clase
Fuente: Elaboración propia
Usando las bondades de la API de Mininet se invoca topo con el método __init__
Es un constructor, init recibe parámetros y asigna los campos a la nueva instancia
de la clase. Puede validar los argumentos, hacer cómputos y métodos de llamadas.
Ilustración 33. Importación de la clase topo
Fuente: Elaboración propia
Recibiendo la cantidad de nodos se realiza la asignación de los host, links y switches
por medio de un ciclo “FOR”.
58
Ilustración 34. Definición nodos y asignación host
Fuente: Elaboración propia
y se finaliza la clase definiéndola como topología tipo waxman.
“topos” es una palabra reservada al igual que lambda, a esta última se le asigna el
nombre de la clase para que pueda ser ejecutada al invocar el script.
Ilustración 35. Definiendo Waxman como clase tipo Topo
Fuente: Elaboración propia
59
8.10 INCLUSIÓN EN LA API
La API de MiniNet está construida en tres niveles:
API de bajo nivel: Consta de las clases de nodo base y de enlace (host, switch, link).
API de nivel medio: Sirve como contenedor para los nodos y enlaces. Proporciona
una serie de métodos (como AddHost (), addSwitch (), y addLink ()) para agregar
nodos y enlaces a una red, puesta en marcha y detenida (start () y stop ())
API de alto nivel: La API de alto nivel añade una abstracción plantilla de topología,
la clase topo, que ofrece la posibilidad de crear plantillas de topología reutilizables,
parametrizadas. Estas plantillas se pueden ejecutar desde la línea de comando con
mn (a través de la opción --custom) y se utilizan desde la línea de comandos.
Para utilizar la API Python de MiniNet el código se graba con extensión .py para que
sea reconocido como documento de Python desde Mininet. Este documento se
guarda en la carpeta CUSTOM de la API de Mininet para luego ser ejecutado.
Ilustración 36. Ejemplo ejecución topología
Fuente: Elaboración propia
O como:
Ilustración 37. Otro Ejemplo ejecución topología
Fuente: Elaboración propia
Al momento de la ejecución se deben llenar los valores que piden las variables
_lamda, alpha, beta y límites. El resultado es la creación de los nodos como se
muestra en el siguiente gráfico:
60
Ilustración 38. Ejecución Waxman.py
Fuente: Elaboración propia
8.11 RESULTADO
Como punto principal se obtuvo el conocimiento de esta nueva alternativa en redes
que se proyecta fuertemente hacia el futuro, de Python como lenguaje de
programación (nuevo para nosotros) se reconoce el potencial de Mininet como
plataforma no solo para el tema de SDN sino para el tema experimental en general,
similar a Mathlab. Fue largo el tiempo de estudio, documentación, pruebas para
llegar a la realización de este documento.
61
Durante el desarrollo del generador se observó que las diferentes propuestas de
topologías personalizadas implementadas para Mininet no cuentan con opciones
dinámicas para el cambio de parámetros desde la línea de comando.
Mininet como herramienta es muy ágil e incluye todo lo necesario para la para
investigación en RDS con la limitante de no poseer interfaz gráfica, por lo que se
sugiere previamente tener conocimientos básicos del sistema operativo Linux, y del
lenguaje de programación Phyton para el desarrollo de los scripts que permiten la
generación de las topologías o componentes personalizados.
Una vez finalizado el desarrollo del código se obtiene un generador aleatorio de
topologías que recibe desde la línea de comando los parámetros para su ejecución,
en esto se diferencia especialmente de las plantillas o modelos almacenados en
Mininet que vienen con los valores pregrabados y que requieren editar el documento
para cambiar los valores, o que no se pueden cambiar porque son ejemplos
específicos.
8.12 OBSERVACIONES
Queda el documento de libre manipulación para quienes sean inquietos en el tema
para que modifiquen, mejoren, corrijan, complementen o lo que consideren
pertinente.
Hay mejoras que se pueden realizar, como reducir algunas líneas de código que se
identificaron cómo susceptibles de mejora, o incluir las aristas en el gráfico; ítems
que no son del alcance de este proyecto.
62
9. PRESUPUESTO
Para ejecutar el desarrollo de este proyecto se requieren 3 computadores
personales con las características básicas funcionales, y un entorno de red para
realizar las pruebas pertinentes a medida que avanza el desarrollo del aplicativo.
Se cuenta con las instalaciones del laboratorio de telecomunicaciones de la UCP
que cuenta la cantidad de equipos requeridos.
Elementos Requeridos
Se relacionan los elementos físicos requeridos para el desarrollo del proyecto, no
se determina presupuesto de inversión ya que contamos con el acceso a estos en
la UCP.
Tabla 1. Equipos Cómputo
EQUIPOS DE CÓMPUTO
CANTIDAD
COSTO
Computador Portátil
3
$4.500.000
Router Gama Baja
1
$100.000
TOTAL
$ 4.600.000
Tabla 2. Costos Administrativos
COSTOS ADMINISTRATIVOS
DESCRIPCIÓN
VALOR
Transporte
Papelería
$ 720,000
$ 100,000
TOTAL
$ 820,000
El software necesario para las actividades de desarrollo es gratuito (Mininet, Phyton,
NOX), por lo que no se requiere realizar inversión en licencias.
Presupuesto de Inversión
La inversión requerida para la puesta en marcha del proyecto se enfoca en los
elementos de papelería y transportes de los integrantes necesarios para el
levantamiento de la documentación y reuniones respectivamente.
63
Tabla 3. Presupuesto de Inversiones
PRESUPUESTO DE INVERSIONES
CONCEPTO
CAPITAL DE TRABAJO
Costos y Gastos Efectivos
Equipos
TOTAL INVERSIONES
PARTICIPACION POR ÁREA
DISTRIBUCIÓN
PRODUCC.
$
$
$
$
0.0%
$
6.000.000
$
820.000
$
4.600.000
$
5.420.000
100.0%
ADMON.
$
$
$
$
0.0%
-
VENTAS
$
$
$
$
0.0%
Recursos Humanos
Se compone de 3 estudiantes de Ingeniería de Sistemas y Telecomunicaciones.
Para este proyecto se requiere personal idóneo con formación básica en sistema
operativo Linux (Ubuntu), lenguaje de programación Python y conocimientos
avanzados en telecomunicaciones.
64
10. CRONOGRAMA
Ilustración 39. Cronograma
Fuente: Elaboración propia
65
11. CONCLUSIONES Y RECOMENDACIONES
En el desarrollo del proyecto se encuentra un lenguaje de programación no conocido
por los integrantes del proyecto, incluyendo el emulador de SDN lo que dificultó el
desarrollo del código; la documentación fue amplia para conocer los conceptos
básicos de programación en este lenguaje.
Asi mismo la documentación está en su gran mayoría en inglés, siendo este idioma
un reto más a superar para la continuidad del proyecto; la poca documentación en
nuestro idioma es incipiente y generalmente copia de las páginas oficiales, por lo
que realmente no aportan suficientemente al objetivo propuesto.
El desarrollo realizado permite a estudiantes e investigadores el estudio, práctica e
implementación de nuevos servicios, ayuda generando topologías complejas de
forma más ágil y así estudiar su comportamiento para una mejor gestión de red.
Durante el desarrollo se evidenciaron muchas dificultades, como el acceso a la
información, actualmente es poca y el apoyo que se puede tener al respecto es
reducido, esto demuestra que cada vez universidades deben enfocarse más en la
enseñanza de las SDN porque son el presente y el futuro de las telecomunicaciones,
muchos fabricantes e industriales ya están eligiendo ser parte porque validaron su
eficiencia y rentabilidad. Hay mucho por hacer, mucho por desarrollar y muchos
desafíos por cumplir.
Mininet como herramienta es muy ágil e incluye todo lo necesario para la para
investigación en RDS con la limitante de no poseer interfaz gráfica, por lo que se
sugiere previamente tener conocimientos básicos del sistema operativo Linux, y del
lenguaje de programación Phyton para el desarrollo de los scripts que permiten la
generación de las topologías o componentes personalizados.
Con este prototipo de SDN, se tiene una base para realizar otras implementaciones,
ya que el tema de las SDN es bastante amplio. Las aplicaciones que se pueden
realizar son muy vastas ya que estas redes son muy versátiles.
Como menciona Carl Sagan en la serie Cosmos, "Recientemente nos hemos
adentrado un poco en el mar, vadeando lo suficiente para mojarnos los dedos de
los pies, o como máximo para que el agua nos llegara al tobillo. " Así estamos en lo
referente a las SDN y quienes desarrollamos este proyecto estamos, más que
generando soluciones, brindando un medio para experimentar, para crear más
inquietudes que al final son las que nos llevan al desarrollo del conocimiento.
66
REFERENCIAS
Adelstein, F., Hosch, F., Richard, G. G., & Schwiebert, L. (1988). Portable Generation of Network
Topologies. 5.
Adjacency List and Adjacency Matrix in Python. (2012). Retrieved from
http://stackoverflow.com/questions/13547133/adjacency-list-and-adjacency-matrix-inpython
Bayer, M. (n.d.). Mako. Retrieved from Mako: http://www.makotemplates.org/
Beiró, M. G. (2010). Modelos Combinatorios de Sistemas Complejos:. 180.
Bogdan Ciubotaru, G.-M. M. (2013). Advanced Network Programming – Principles and Techniques.
Springer.
Brite Boston University representative Internet Topology Generator. (2014). Retrieved from
http://www.cs.bu.edu/brite/
Cecilia Urbina Topologias y ruteos. (2013). Retrieved from http://ceciliaurbina.blogspot.com.co/2013/04/topologias-y-ruteos.html
Community, T. S. (2008-2014). Scipy.org. Retrieved from http://docs.scipy.org/doc/scipy0.15.1/reference/generated/scipy.stats.poisson.html
Community, T. S. (2008-2014). SciPY.org. Retrieved from
http://docs.scipy.org/doc/numpy/reference/generated/numpy.random.uniform.html
Coonor Johnson. (2014). Retrieved from http://connor-johnson.com/2014/02/25/spatial-pointprocesses/
CoSDN - Cognitive Software Defined Networks. (2015). Retrieved from
http://wwwen.uni.lu/snt/research/netlab/projects/cosdn_cognitive_software_defined_ne
tworks
Cursos de Programacion a Distancia. (2015). Retrieved from
http://www.cursosdeprogramacionadistancia.com/static/pdf/material-sin-personalizarpython.pdf
Developers, N. (2013). numpy.org. Retrieved from numpy.org: http://www.numpy.org/
Developers, S. (2015). Scipy. Retrieved from Scipy: http://www.scipy.org/
Erdos, P., & Renyi, A. (1958). On random graphs I. 8.
67
Faloutsos, M., Faloutsos, P., & Faloutsos, C. (1999). On Power-Law Relationships of the Internet
Topology. 12.
Fast Network Simulation Setup. (2013). Retrieved from http://fnss.github.io/
Fei, Z., Xu, Q., & Lu, H. (2014). Generating Large Network Topologies for GENI. 7.
Foundation, O. N. (2012). Open Networking Foundation. Retrieved from
https://www.opennetworking.org
Foundation, O. N. (2015). Open Networking Foundation. Retrieved from
https://www.opennetworking.org/component/sfg/?view=form&Itemid=143
Gephi Makes Graphs Handy. (2008-2015). Retrieved from https://gephi.github.io/features/
Git Hub. (2008). Retrieved from https://github.com/mininet/mininet/wiki/Introduction-to-Mininet
Git Hub. (2013). Retrieved from https://github.com/ryazwinski/mcat/blob/master/setup.py
Git Hub. (2015). Retrieved from https://github.com/scipy/scipy#what-is-scipy
GitHub Mininet, P. (n.d.). Introduction to Mininet. Retrieved from Introduction to Mininet:
https://github.com/mininet/mininet/wiki/Introduction-to-Mininet#api
github. (n.d.). raw.githubusercontent.com. Retrieved from raw.githubusercontent.com:
https://raw.githubusercontent.com/fnss/fnss-vm/master/setup.sh
Grupo de Investigacion de la Universidad de Antiquia. (2015). Retrieved from
http://ingenieria.udea.edu.co/investigacion/
Guia Rapida de Python. (2015). Retrieved from
https://sites.google.com/site/pythoncolombia/guia-rapida-de-python
Haggerty, M. (n.d.). Gnuplot.py en SourceForge. Retrieved from Gnuplot.py en SourceForge:
http://gnuplot-py.sourceforge.net/
Hunter, J., Dale, D., Firing, E., Droettboom, M., & Developers Team, M. (2012 - 2015). matplotlib.
Retrieved from matplotlib: http://matplotlib.org/
InCNTRE's SDN Interoperability Lab. (2015). Retrieved from http://incntre.iu.edu/SDNlab
Inda, A., Bravo, G., & Flores, F. (2009). AUTOMATIC NETWORK TOPOLOGY GENERATOR FOR
TRANSMISSION PLANNING. 9.
Instalando Paguetes de Python. (2015). Retrieved from
http://www.manejandodatos.es/2013/10/instalando-paquetes-de-python/
Installation Instructions. (2015). Retrieved from http://cvxopt.org/install/index.html
68
Introduction to Mininet. (n.d.). Retrieved from
https://github.com/mininet/mininet/wiki/Introduction-to-Mininet
Jupyter Notebook Viewer. (2015). Retrieved from
http://nbviewer.ipython.org/github/gfrubi/clases-python-cientifico/blob/master/Lecture2-Numpy.ipynb
Laszlo Barabasi, A., & Albert, R. (1999). Emergence of Scaling in. 4.
LFD. (2015). Retrieved from http://www.lfd.uci.edu/~gohlke/pythonlibs/#scipy
Magoni, D. (2002). nem: A Software for Network Topology Analysis and Modeling. 8.
Magoni, M., & Pansiot, J.-J. (2002). sis and Comparison of Internet Topology. 12.
Martinez Copete, J. E. (2015). SDN - Mininet last version V5. In J. E. Martinez Copete. Pereira
Risaralda Colombia.
Math Synonyms. (2006). Retrieved from http://mathesaurus.sourceforge.net/math-synonyms.pdf
Mathesaurus. (2007). Retrieved from http://mathesaurus.sourceforge.net/matlab-numpy.html
Matlab Python Xref. (2006). Retrieved from http://mathesaurus.sourceforge.net/matlab-pythonxref.pdf
Matlab Sparse. (2008). Retrieved from
http://mat21.etsii.upm.es/matesp/clases/clases0809/clase04/MatlabSparse.pdf
Matlab to python code conversion. (2012). Retrieved from
http://stackoverflow.com/questions/11674841/matlab-to-python-code-conversion
Matplotlib 1.5.0 Documentation. (2002-2012). Retrieved from
http://matplotlib.org/examples/api/unicode_minus.html
Matplotlib 1.5.0 Documentation. (2012). Retrieved from http://matplotlib.org/
Medina, A. (2001). Generadores de Topologias Disponibles. Retrieved from http://www.cs.bu.edu/
Medina, A., Lakhina, A., Matta, I., & Byers, J. (2001). BRITE: An Approach to Universal Topology
Generation. 8.
Megasolution. (2015). Retrieved from http://www.megasolutions.net/python/Does-Python-haveequivalent-to-MATLAB--varargin-,--varargout-,--nargin-,--nargout_-14798.aspx
Mininet Walkthrough. (2015). Retrieved from http://mininet.org/walkthrough/#custom-topologies
Naldi, M. (2005). Connectivity of Waxman topology models. 8.
NC State University. (2014). Retrieved from https://www.ncsu.edu/
69
NetworkX Equipo desarrollador. (2014). NetworkX. Retrieved from NetworkX:
https://networkx.github.io/
Numerical Python Browse. (2015). Retrieved from
http://sourceforge.net/projects/numpy/files/NumPy/1.9.2/
Numpy v1.0 Manual. (2008-2009). Retrieved from
http://docs.scipy.org/doc/numpy/user/install.html
ONRC Research. (2014). Retrieved from http://onrc.stanford.edu/
Open Networking Foundation. (2015). Retrieved from
https://www.opennetworking.org/component/sfg/?view=form&Itemid=143
Org Cython. (n.d.). Cython C-Extensions for Python. Retrieved from http://cython.org/
Paper, O. W. (2012). Open Networking Foundation. Retrieved from
https://www.opennetworking.org
Pip 7.1.2 Documentation. (n.d.). Retrieved from https://pip.pypa.io/en/latest/installing/#install-pip
Project, M. (n.d.). Mininet Download. Retrieved from Mininet Download:
http://mininet.org/download/
Python 2.7.10 Documentation. (2009-2015). Retrieved from
https://docs.python.org/2/library/random.html
Python Library Import. (2008). Retrieved from
http://ubuntuforums.org/showthread.php?t=917516
Python Package Index. (1990-2015). Retrieved from https://pypi.python.org/pypi/setuptools/
Python para Principiantes. (2011-2013). Retrieved from
http://librosweb.es/libro/python/capitulo_4/llamadas_de_retorno.html
Python Software Foundation. (1990-2015). Retrieved from https://pypi.python.org/pypi/pymatlab
Python Software Foundation. (2015). Retrieved from
https://packaging.python.org/en/latest/projects/#pip
python.org. (n.d.). Python-Dev, desarrolladores del núcleo de Python. Retrieved from
https://mail.python.org/mailman/listinfo/python-dev
pythontesting. (n.d.). Python Test Frameworks and Strategies. Retrieved from Python Test
Frameworks and Strategies: http://pythontesting.net/framework/nose/nose-introduction/
Quoitin, B., & Lepropre, J. (2010). Topology generation through network design heuristics.
Retrieved from http://informatique.umons.ac.be/networks/igen/
70
Read filesin Python. (2015). Retrieved from http://stackoverflow.com/questions/874461/readmat-files-in-python
Rényi and, E. (1960). Publicationes Mathematicae Debrecen.
Reproducing Network Research. (2012). Retrieved from
https://reproducingnetworkresearch.wordpress.com/2012/06/04/jellyfish-vs-fat-tree/
Saino, L. (2014). A Toolchain for Simplifying Network Simulation Setup. 10.
Saino, L., & Cocora, C. (2012-2015). Fast Network Simulation Setup (FNSS). Retrieved from Fast
Network Simulation Setup (FNSS): http://fnss.github.io/doc/core/
Scipy.org. (n.d.). Retrieved from http://www.scipy.org/scipylib/download.html
Scipy.org. (2008-2014). Retrieved from http://docs.scipy.org/doc/scipy0.15.1/reference/generated/scipy.stats.poisson.html
SciPy.org. (2008-2014). Retrieved from https://docs.scipy.org/doc/scipy/reference/sparse.html
SDN Academy. (2015). Retrieved from http://sdnacademy.com/
Sebastian Raschka. (2014). Retrieved from
http://sebastianraschka.com/Articles/2014_matrix_cheatsheet_table.html
Slide Share. (2013). Retrieved from http://es.slideshare.net/rjain51/m-15oct?related=2
Software Foundation, P. (1990-2015). docs.python.org. Retrieved from docs.python.org:
https://docs.python.org/3/library/distutils.html
SRL, K. I. (2015). Kit Electronica. Retrieved from Kit Electronica: http://www.kit.com.ar/boletinesa.php?id=0000140
Stack Over Flow. (2012). Retrieved from http://stackoverflow.com/questions/10555593/randomadjacency-matrix-with-variation-on-number-of-edges-per-node
Stack Over Flow. (2012). Retrieved from http://stackoverflow.com/questions/2180299/range-ofpythons-random-random-from-the-standard-library
The IPython Development, T. (n.d.). IP [y]. Retrieved from IP [y]: https://ipython.org/ipythondoc/3/interactive/qtconsole.html
The Plone Foundation, a. f. (2000-2013). Plone. Retrieved from Plone:
https://plone.org/countries/mx/instalacion-de-setuptools-y-easyinstall-para-python
TuxyLinux.com. (2015). Tuxylinux. Retrieved from Tuxylinux: http://www.tuxylinux.com/instalar-yconfigurar-wireshark-en-linux/
71
Vaamonde, S. R. (2013). De Matlab a Python. Retrieved from
https://srodriguezv.wordpress.com/2013/07/14/de-matlab-a-python-python-comolenguaje-de-programacion-cientifico-y-tecnico/
Vargas, W. A. (2013). Emulacion de una red definida por software. Retrieved from Emulacion de
una red definida por software:
https://www.academia.edu/5730624/Emulaci%C3%B3n_de_una_red_definida_por_softw
are_utilizando_MiniNet
Velasquez, W. (2015). Emulación de una red definida por software utilizando MiniNet. Retrieved
from Emulación de una red definida por software utilizando MiniNet:
https://www.academia.edu/5730624/Emulaci%C3%B3n_de_una_red_definida_por_softw
are_utilizando_MiniNet
Wang, S.-Y. (2014). Comparison of SDN OpenFlow Network Simulator. 6.
Waxman, B. M. (1988). Routing of Multipoint Connections.
Web Home Groups SDN Victoria University. (2015). Retrieved from
https://ecs.victoria.ac.nz/Groups/SDN/
72
BIBLIOGRAFIA
Adelstein, F., Hosch, F., Richard, G. G., & Schwiebert, L. (1988). Portable Generation of Network
Topologies. 5.
Adjacency List and Adjacency Matrix in Python. (2012). Retrieved from
http://stackoverflow.com/questions/13547133/adjacency-list-and-adjacency-matrix-inpython
Bayer, M. (n.d.). Mako. Retrieved from Mako: http://www.makotemplates.org/
Beiró, M. G. (2010). Modelos Combinatorios de Sistemas Complejos:. 180.
Bogdan Ciubotaru, G.-M. M. (2013). Advanced Network Programming – Principles and Techniques.
Springer.
Brite Boston University representative Internet Topology Generator. (n.d.). Retrieved from
http://www.cs.bu.edu/brite/
Cecilia Urbina Topologias y ruteos. (2013). Retrieved from http://ceciliaurbina.blogspot.com.co/2013/04/topologias-y-ruteos.html
Community, T. S. (2008-2014). Scipy.org. Retrieved from http://docs.scipy.org/doc/scipy0.15.1/reference/generated/scipy.stats.poisson.html
Community, T. S. (2008-2014). SciPY.org. Retrieved from
http://docs.scipy.org/doc/numpy/reference/generated/numpy.random.uniform.html
Coonor Johnson. (2014). Retrieved from http://connor-johnson.com/2014/02/25/spatial-pointprocesses/
CoSDN - Cognitive Software Defined Networks. (2015). Retrieved from
http://wwwen.uni.lu/snt/research/netlab/projects/cosdn_cognitive_software_defined_ne
tworks
Cursos de Programacion a Distancia. (2015). Retrieved from
http://www.cursosdeprogramacionadistancia.com/static/pdf/material-sin-personalizarpython.pdf
Developers, N. (2013). numpy.org. Retrieved from numpy.org: http://www.numpy.org/
Developers, S. (2015). Scipy. Retrieved from Scipy: http://www.scipy.org/
Erdos, P., & Renyi, A. (1958). On random graphs I. 8.
73
Faloutsos, M., Faloutsos, P., & Faloutsos, C. (1999). On Power-Law Relationships of the Internet
Topology. 12.
Fast Network Simulation Setup. (2013). Retrieved from http://fnss.github.io/
Fei, Z., Xu, Q., & Lu, H. (2014). Generating Large Network Topologies for GENI. 7.
Foundation, O. N. (2012). Open Networking Foundation. Retrieved from
https://www.opennetworking.org
Foundation, O. N. (2015). Open Networking Foundation. Retrieved from
https://www.opennetworking.org/component/sfg/?view=form&Itemid=143
Gephi Makes Graphs Handy. (2008-2015). Retrieved from https://gephi.github.io/features/
Git Hub. (2008). Retrieved from https://github.com/mininet/mininet/wiki/Introduction-to-Mininet
Git Hub. (2013). Retrieved from https://github.com/ryazwinski/mcat/blob/master/setup.py
Git Hub. (2015). Retrieved from https://github.com/scipy/scipy#what-is-scipy
github. (n.d.). raw.githubusercontent.com. Retrieved from raw.githubusercontent.com:
https://raw.githubusercontent.com/fnss/fnss-vm/master/setup.sh
Grupo de Investigacion de la Universidad de Antiquia. (2015). Retrieved from
http://ingenieria.udea.edu.co/investigacion/
Guia Rapida de Python. (2015). Retrieved from
https://sites.google.com/site/pythoncolombia/guia-rapida-de-python
Haggerty, M. (n.d.). Gnuplot.py en SourceForge. Retrieved from Gnuplot.py en SourceForge:
http://gnuplot-py.sourceforge.net/
Hunter, J., Dale, D., Firing, E., Droettboom, M., & Developers Team, M. (2012 - 2015). matplotlib.
Retrieved from matplotlib: http://matplotlib.org/
InCNTRE's SDN Interoperability Lab. (2015). Retrieved from http://incntre.iu.edu/SDNlab
Inda, A., Bravo, G., & Flores, F. (2009). AUTOMATIC NETWORK TOPOLOGY GENERATOR FOR
TRANSMISSION PLANNING. 9.
Instalando Paguetes de Python. (2015). Retrieved from
http://www.manejandodatos.es/2013/10/instalando-paquetes-de-python/
Installation Instructions. (2015). Retrieved from http://cvxopt.org/install/index.html
Introduction to Mininet. (n.d.). Retrieved from
https://github.com/mininet/mininet/wiki/Introduction-to-Mininet
74
Jupyter Notebook Viewer. (2015). Retrieved from
http://nbviewer.ipython.org/github/gfrubi/clases-python-cientifico/blob/master/Lecture2-Numpy.ipynb
Laszlo Barabasi, A., & Albert, R. (1999). Emergence of Scaling in. 4.
LFD. (2015). Retrieved from http://www.lfd.uci.edu/~gohlke/pythonlibs/#scipy
Magoni, D. (2002). nem: A Software for Network Topology Analysis and Modeling. 8.
Magoni, M., & Pansiot, J.-J. (2002). sis and Comparison of Internet Topology. 12.
Martinez Copete, J. E. (2015). SDN - Mininet last version V5. In J. E. Martinez Copete. Pereira
Risaralda Colombia.
Math Synonyms. (2006). Retrieved from http://mathesaurus.sourceforge.net/math-synonyms.pdf
Mathesaurus. (2007). Retrieved from http://mathesaurus.sourceforge.net/matlab-numpy.html
Matlab Python Xref. (2006). Retrieved from http://mathesaurus.sourceforge.net/matlab-pythonxref.pdf
Matlab Sparse. (2008). Retrieved from
http://mat21.etsii.upm.es/matesp/clases/clases0809/clase04/MatlabSparse.pdf
Matlab to python code conversion. (2012). Retrieved from
http://stackoverflow.com/questions/11674841/matlab-to-python-code-conversion
Matplotlib 1.5.0 Documentation. (2002-2012). Retrieved from
http://matplotlib.org/examples/api/unicode_minus.html
Matplotlib 1.5.0 Documentation. (2012). Retrieved from http://matplotlib.org/
Medina, A. (2001). Generadores de Topologias Disponibles. Retrieved from http://www.cs.bu.edu/
Medina, A., Lakhina, A., Matta, I., & Byers, J. (2001). BRITE: An Approach to Universal Topology
Generation. 8.
Megasolution. (2015). Retrieved from http://www.megasolutions.net/python/Does-Python-haveequivalent-to-MATLAB--varargin-,--varargout-,--nargin-,--nargout_-14798.aspx
Mininet Walkthrough. (2015). Retrieved from http://mininet.org/walkthrough/#custom-topologies
Naldi, M. (2005). Connectivity of Waxman topology models. 8.
NC State University. (2014). Retrieved from https://www.ncsu.edu/
NetworkX Equipo desarrollador. (2014). NetworkX. Retrieved from NetworkX:
https://networkx.github.io/
75
Numerical Python Browse. (2015). Retrieved from
http://sourceforge.net/projects/numpy/files/NumPy/1.9.2/
Numpy v1.0 Manual. (2008-2009). Retrieved from
http://docs.scipy.org/doc/numpy/user/install.html
ONRC Research. (2014). Retrieved from http://onrc.stanford.edu/
Open Networking Foundation. (2015). Retrieved from
https://www.opennetworking.org/component/sfg/?view=form&Itemid=143
Org Cython. (n.d.). Cython C-Extensions for Python. Retrieved from http://cython.org/
Paper, O. W. (2012). Open Networking Foundation. Retrieved from
https://www.opennetworking.org
Pip 7.1.2 Documentation. (n.d.). Retrieved from https://pip.pypa.io/en/latest/installing/#install-pip
Project, M. (n.d.). Introduction to Mininet. Retrieved from Introduction to Mininet:
https://github.com/mininet/mininet/wiki/Introduction-to-Mininet#api
Project, M. (n.d.). Mininet Download. Retrieved from Mininet Download:
http://mininet.org/download/
Python 2.7.10 Documentation. (2009-2015). Retrieved from
https://docs.python.org/2/library/random.html
Python Library Import. (2008). Retrieved from
http://ubuntuforums.org/showthread.php?t=917516
Python Package Index. (1990-2015). Retrieved from https://pypi.python.org/pypi/setuptools/
Python para Principiantes. (2011-2013). Retrieved from
http://librosweb.es/libro/python/capitulo_4/llamadas_de_retorno.html
Python Software Foundation. (1990-2015). Retrieved from https://pypi.python.org/pypi/pymatlab
Python Software Foundation. (2015). Retrieved from
https://packaging.python.org/en/latest/projects/#pip
python.org. (n.d.). Python-Dev, desarrolladores del núcleo de Python. Retrieved from
https://mail.python.org/mailman/listinfo/python-dev
pythontesting. (n.d.). Python Test Frameworks and Strategies. Retrieved from Python Test
Frameworks and Strategies: http://pythontesting.net/framework/nose/nose-introduction/
Quoitin, B., & Lepropre, J. (n.d.). Topology generation through network design heuristics. Retrieved
from http://informatique.umons.ac.be/networks/igen/
76
Read filesin Python. (2015). Retrieved from http://stackoverflow.com/questions/874461/readmat-files-in-python
Rényi and, E. (1960). Publicationes Mathematicae Debrecen.
Reproducing Network Research. (2012). Retrieved from
https://reproducingnetworkresearch.wordpress.com/2012/06/04/jellyfish-vs-fat-tree/
Saino, L. (2014). A Toolchain for Simplifying Network Simulation Setup. 10.
Saino, L., & Cocora, C. (2012-2015). Fast Network Simulation Setup (FNSS). Retrieved from Fast
Network Simulation Setup (FNSS): http://fnss.github.io/doc/core/
Scipy.org. (n.d.). Retrieved from http://www.scipy.org/scipylib/download.html
Scipy.org. (2008-2014). Retrieved from http://docs.scipy.org/doc/scipy0.15.1/reference/generated/scipy.stats.poisson.html
SciPy.org. (2008-2014). Retrieved from https://docs.scipy.org/doc/scipy/reference/sparse.html
SDN Academy. (2015). Retrieved from http://sdnacademy.com/
Sebastian Raschka. (2014). Retrieved from
http://sebastianraschka.com/Articles/2014_matrix_cheatsheet_table.html
Slide Share. (2013). Retrieved from http://es.slideshare.net/rjain51/m-15oct?related=2
Software Foundation, P. (1990-2015). docs.python.org. Retrieved from docs.python.org:
https://docs.python.org/3/library/distutils.html
Stack Over Flow. (2012). Retrieved from http://stackoverflow.com/questions/10555593/randomadjacency-matrix-with-variation-on-number-of-edges-per-node
Stack Over Flow. (2012). Retrieved from http://stackoverflow.com/questions/2180299/range-ofpythons-random-random-from-the-standard-library
The IPython Development, T. (n.d.). IP [y]. Retrieved from IP [y]: https://ipython.org/ipythondoc/3/interactive/qtconsole.html
The Plone Foundation, a. f. (2000-2013). Plone. Retrieved from Plone:
https://plone.org/countries/mx/instalacion-de-setuptools-y-easyinstall-para-python
TuxyLinux.com. (2015). Tuxylinux. Retrieved from Tuxylinux: http://www.tuxylinux.com/instalar-yconfigurar-wireshark-en-linux/
Vaamonde, S. R. (2013). De Matlab a Python. Retrieved from
https://srodriguezv.wordpress.com/2013/07/14/de-matlab-a-python-python-comolenguaje-de-programacion-cientifico-y-tecnico/
77
Vargas, W. A. (2013). Emulacion de una red definida por software. Retrieved from Emulacion de
una red definida por software:
https://www.academia.edu/5730624/Emulaci%C3%B3n_de_una_red_definida_por_softw
are_utilizando_MiniNet
Wang, S.-Y. (2014). Comparison of SDN OpenFlow Network Simulator. 6.
Waxman, B. M. (1988). Routing of Multipoint Connections.
Web Home Groups SDN Victoria University. (2015). Retrieved from
https://ecs.victoria.ac.nz/Groups/SDN/
78
ANEXO 1
GUÍA DE INSTALACIÓN MININET
Mininet ofrece dos formas de utilización, una forma Virtualizada a través de un
Virtual Box u otro software similar, y la otra de forma nativa en S.O Ubuntu 14.04 o
superior.
La forma utilizada para este proyecto es de manera Nativa con S.O Ubuntu 14.04.
(Project, Mininet Download, s.f.)
INSTALACIÓN NATIVA DE MININET EN UBUNTU 14.04.
Para instalarse MiniNet (es decir, ‘mn’ en la API de Python) en Ubuntu 14+ o
superior, basta con ejecutar los siguientes comandos desde la terminal: (Project,
Mininet Download, s.f.)
Ilustración 40. Terminal Ubuntu
Fuente: Elaboración propia
79
Para la instalación de Mininet de forma nativa desde la fuente se debe introducir:
git clone git://github.com/mininet/mininet
Ilustración 41. Instalar Mininet desde terminal
Fuente: Elaboración propia
Una vez que tenga el árbol de fuentes, el comando para instalar MiniNet es:
mininet/util/install.sh –a
Ilustración 42. Instalar Mininet
Fuente: Elaboración propia
-a: instala todo lo que se incluye en el MiniNet VM, incluyendo dependencias como
Open vSwitch así las adiciones como el disector Wireshark OpenFlow y POX.
Después de la instalación se ha completado, probar la funcionalidad básica MiniNet:
sudo mn --test pingall
Ilustración 43. sudo mn --test pingall
Fuente: Elaboración propia
80
LISTADO DE COMANDOS UTILES EN MININET
Fuente: SDN-Mininet last version_V5 (Martinez Copete, 2015)
COMANDOS PARA GENERAR TOPOLOGIAS
$Sudo mn : Crea una topología por default con 1 switch, 1 controlador y 2 hosts.
Ilustración 44. sudo mn
Fuente: Elaboración propia
$sudo mn --topo single,N
Para crear una topología single de N host, donde N es el número de hosts deseados.
Ilustración 45. sudo topo single
Fuente: Elaboración propia
81
$sudo mn --topo linear,N
Crea una topología linear de N host y N switches, donde N es el número de hosts y
switches deseados.
Ilustración 46. sudo topo linear
Fuente: Elaboración propia
sudo mn --topo tree,N
Crea una topología en árbol de N host y N switches.
Ilustración 47. sudo topo tree
Fuente: Elaboración propia
82
COMANDOS DE PRUEBAS
Mininet>link [node1][node2][up o down]
Crea o elimina un o link entre dos nodos.
Ilustración 48. link
Fuente: Elaboración propia
Mininet>h1 ping h2
Instrucción para saber si hay conectividad entre un host de origen (h1) y un host de
destino (h2).
Ilustración 49. h1 ping h2
Fuente: Elaboración propia
Mininet>pingall
Prueba conectividad entre dos nodos.
Ilustración 50. pingall
Fuente: Elaboración propia
83
Mininet>pinpair
Realiza un test de conectividad entre las diferentes parejas de host de la red.
Ilustración 51. pingpair
Fuente: Elaboración propia
Mininet>iperf
Comando para la caracterización del ancho de banda entre host.
Ilustración 52. iperf
Fuente: Elaboración propia
Mininet>nodes
Muestra los nodos de la topología.
Ilustración 53. nodes
Fuente: Elaboración propia
Mininet>dump
Con el comando dump, se observa la información de todos los nodos que hacen
parte de la topología.
Ilustración 54. dump
Fuente: Elaboración propia
84
Mininet>net
Con este comando se muestra como están conectados los dispositivos de la red.
Ilustración 55. net
Fuente: Elaboración propia
Mininet>eof
Detiene los dispositivos de la red y la cierra.
Ilustración 56. eof
Fuente: Elaboración propia
Mininet>s(número del switch) arp
Comando para el protocolo de resolución de direcciones.
Ilustración 57. s1 arp
Fuente: Elaboración propia
85
Mininet> h(número del host) ifconfig
Muestra la configuración de la interfaz del host
Ilustración 58. h1 if config
Fuente: Elaboración propia
Mininet> s(número del switch) ifconfig
Muestra la configuración de la interfaz del switch.
Ilustración 59. s1 ifconfig
Fuente: Elaboración propia
86
Mininet>h(número del host) ps
Imprime la lista de procesos a partir de un proceso de hosts.
Ilustración 60. h1 ps
Fuente: Elaboración propia
Mininet>s(número del switch) ps
Imprime la lista de procesos del switch.
Ilustración 61. s1 ps
Fuente: Elaboración propia
COMANDOS FUNCIONALES
Mininet>exit
Salir de Mininet
Ilustración 62. exit
Fuente: Elaboración propia
87
Mininet>help
Ayuda, muestra lista de comandos de Mininet
Ilustración 63. help
Fuente: Elaboración propia
Sudo su
Entrar en modo privilegiado
Ilustración 64. sudo su
Fuente: Elaboración propia
88
INSTALACION DE LIBRERÍAS Y PAQUETES REQUERIDOS
En lo siguiente se explican las diferentes librerías y paquetes que fueron
necesarias instalar para la ejecución de la topología Waxman.
Librería FNSS:
Es una biblioteca de Python que proporciona un conjunto de características que
permiten simplificar la configuración de un experimento de red.
La biblioteca central contiene adaptadores para exportar escenarios generados a una
de
los
siguientes
simuladores
de
red
o
emuladores:
ns2, MiniNet, omnet ++, jFed y Autonetkit. (Saino & Cocora, Fast Network Simulation
Setup (FNSS), 2012-2015)
sudo pip install -U fnss
Ilustración 65. Instalación librería FNSS
Fuente: Elaboración propia
Wireshark
Wireshark es una herramienta de red que captura el tráfico de la máquina dónde se
está ejecutando y nos muestra mediante su interfaz gráfica los paquetes
capturados. (TuxyLinux.com, 2015)
sudo apt-get install wireshark
Ilustración 66. Instalación Wireshark
Fuente: Elaboración propia
89
Librerías, utilidades y paquetes para Python 2.
La siguiente son unas líneas de código que permite la instalación de librerías,
utilidades y paquetes que fueron necesarios para la ejecución de la topología
Waxman.py. Seguido de la ilustración (64) se define cada una de ellas.
sudo apt-get -y -q install python ipython python-pip python-setuptools cython ipythonnotebook ipython-qtconsole
sudo apt-get -y -q install python-dev python-scipy python-numpy python-matplotlib pythonnetworkx python-gnuplot python-mako python-nose (github, s.f.)
Ilustración 67. Instalación librerías
Fuente: Elaboración propia
SetupTools: Setuptools es una colección de mejoras para el módulo
distutils de Python, que permiten a un desarrollador construir y distribuir
paquetes de Python de forma sencilla, en especial cuando dependen de otros
paquetes de Python para funcionar. (The Plone Foundation, 2000-2013)
El distutils mencionado en el párrafo anterior es el paquete que proporciona
soporte para la construcción e instalación de módulos adicionales en una
instalación de Python. (Software Foundation, 1990-2015)
Librería Cython: El lenguaje Cython es un súper conjunto del lenguaje
Python que apoya el llamado a funciones C y declara tipos C sobre
variables y atributos de clase. Cython le da el poder combinado de Python
y C para que pueda escribir código Python que llama de ida y vuelta desde
y hacia C o C ++ código de forma nativa en cualquier punto. (Org Cython)
Qtconsole: Es un widget que se siente en gran medida como un terminal,
pero ofrece una serie de mejoras en una interfaz gráfica de usuario, tales
como figuras en línea, edición multilínea adecuada con resaltado de sintaxis,
gráficos, y mucho más. (The IPython Development, s.f.)
Dev: Es la lista de los principales desarrolladores de Python para discutir el
futuro de la lengua y su aplicación. Los temas incluyen cuestiones Python,
diseño, la mecánica de liberación, y el mantenimiento de las emisiones
existentes. (python.org, s.f.)
90
Librería SciPy: (pronunciado "Suspiro Pie") es un ecosistema basado en
Python del software de código abierto para las matemáticas, la ciencia y la
ingeniería. SciPy es una colección de algoritmos matemáticos y funciones de
conveniencia construidas sobre la extensión Numpy de Python.
Con SciPy una sesión interactiva de Python se convierte en un entorno de
procesamiento de datos y el sistema de prototipado rivalizando Sytems como
MATLAB, IDL, Octave, R-Lab y SciLab. (Developers S. , 2015)
Librería numpy: NumPy es el paquete fundamental para la computación
científica con Python, en especial para el manejo de matrices con N
dimensiones, álgebra lineal, transformaciones de Fourier, y capacidades de
números aleatorios. (Developers, 2013)
NetworkX: es un paquete de software de lenguaje Python para la creación,
manipulación, y el estudio de la estructura, la dinámica y las funciones de redes
complejas. (NetworkX Equipo desarrollador, 2014)
Gnuplot: es un paquete de Python que se conecta a gnuplot, el programa
trazado de código abierto muy popular. Se permite el uso de gnuplot desde
dentro de Python para trazar conjuntos de datos de la memoria, los archivos
de datos o funciones matemáticas. (Haggerty, s.f.)
Mako: es una biblioteca de plantillas escrito en Python. Proporciona una
sintaxis familiar, no XML que compila en módulos de Python para el máximo
rendimiento. (Bayer, s.f.)
Nose: Es un marco de pruebas bastante conocido como unidad de Python y
se puede ejecutar prueba unitaria, unittests y pruebas "no repetitivo".
(pythontesting, s.f.)
Librería Matplotlib: Matplotlib es una biblioteca python 2D que produce figuras de
calidad. Matplotlib se puede utilizar en scripts python, Puede generar parcelas,
histogramas, los espectros de potencia, gráficos de barras, diagramas de
dispersión, etc, con sólo unas pocas líneas de código. (Hunter, Dale, Firing,
Droettboom, & Developers Team, 2012 - 2015)
sudo apt-get install python-matplotlib
Ilustración 68. Instalación librería matpotlib
91
EJECUCIÓN ARCHIVO PYTHON
Para importar el archivo waxman.py en el cual está el desarrollo de nuestra
topología, se deben realizar los siguientes pasos:
1. Inicialmente el archivo desarrollado debe estar creado en python para que
pueda ser reconocido por la API.
2. El archivo python debe estar almacenado en la siguiente ruta:
/home/diego/mininet/custom/Waxman.py
home/diego: es el nombre del equipo y usuario de la maquina donde se instaló
la API.
3. Para la ejecución del archivo Waxman.py, lo hacemos desde la línea de
comandos de la siguiente manera:
sudo su : para ingresar en modo privilegiado
contraseña: ( la establecida inicialmente)
cd Mininet : para acceder al directorio de la API
cd custom : para ingresar a la carpeta donde se almacena el archivo python
ls : nos muestra los archivos existentes en la carpeta
Ilustración 69. Ingreso a ruta desde la API
Fuente: Elaboración propia
Para abrir el archivo python desarrollado escribimos sudo python Waxman.py
Ilustración 70. Abrir archivo python Waxman.py
Fuente: Elaboración propia
92
Ejecución topología Waxman.py
sudo python Waxman.py
Al ingresar el comando nos solicita valores de los parámetros necesarios para su
ejecución. Se debe tener en cuenta que los valores de lamda, alpha y beta deben
ser menores de 1 debido que se trata de probabilidades.
Ilustración 71. Ejecución Waxman.py
Fuente: Elaboración propia
Luego de introducido los valores, el script genera los nodos y los distribuye en el
plano y procede a representar gráficamente.
Ilustración 72. Vista ejecución archivo Waxman.py
Fuente: Elaboración propia
93
CREAR Y EDITAR TOPOLOGÍAS DESDE EL EDITOR NANO EN UBUNTU
Para crear una topología desde el editor nano (editor de textos para la terminal) en
Ubuntu navegamos hasta la carpeta en la que deseamos guardar el archivo con las
líneas de código python, para posteriormente ejecutar la topología creada. Para
editar una topología se sigue un proceso similar al de crear una, ya que se tiene que
navegar por el directorio hasta llegar a la carpeta que contiene el archivo deseado,
con la variante de que al encontrar el archivo se abrirá con las líneas de código que
contiene. (Martinez Copete, 2015, págs. 66-68).
Gráficamente seria así:
Ejecutamos nano: Al escribir nano y pulsar Enter automáticamente se abre el editor.
Ilustración 73. Editor nano
Fuente: Elaboración propia
Seguimos los pasos indicados en la parte inferior para buscar y abrir el archivo
correspondiente:
Ilustración 74. Modificación de archivo desde nano
Fuente: Elaboración propia
Como último paso guardamos el archivo en la ruta especificada al momento de
almacenar.
94
CONTROLADOR POR DEFECTO DE MININET POX
POX es un controlador OpenFlow desarrollado para cubrir los requerimientos de las
SDN usando el lenguaje de programación Python. Además de ser un framework
para la interacción con los switches de OpenFlow, está siendo usado para explorar
nuevos prototipos de redes con distribución, para la depuración de las SDN y el
diseño de controladores.
Algunas de las características más relevantes de POX son:
- Interfaz OpenFlow basada en Python.
- Los componentes muestran la selección de ruta de acceso, detección de la
topología, entre otras. (Martinez Copete, 2015, pág. 73).
95
ANEXO 2
CÓDIGO PYTHON TOPOLOGÍA WAXMAN.PY
A continuación se enseña código completo para el desarrollo de la topología
Waxman.py en lenguaje Python.
# -*- coding: utf-8 -*## Codificación estándar e importación de librerías
import scipy.io as sio
import string
import random
import math
import numpy as np
import scipy as Sci
import scipy.stats as stats
import scipy.sparse as sp
import scipy.linalg
from scipy.sparse import csr_matrix
import matplotlib
import matplotlib.pyplot as plt
#Importacion de librerías para generar la red
from mininet.net import Mininet
from mininet.topo import Topo
from mininet.node import RemoteController
from mininet.util import irange
from mininet.cli import CLI
96
class waxman(Topo):
"Asignacion de un host a cada nodo calculado, y un switch por nodo."
def __init__(self, k, **opts):
"""Init.
k: numero de host y switch"""
Topo.__init__( self )
lastSwitch = None
for i in irange(1, k):
host = self.addHost('h%s' % i)
switch = self.addSwitch('s%s' % i)
self.addLink( host, switch)
if lastSwitch:
self.addLink( switch, lastSwitch)
lastSwitch = switch
## Definicion de la funcion waxman (página 52)
def waxman(_lambda=0.6, alpha=0.4, beta=0.2, limites=(1, 10, 1, 10)):
# Validación de ingreso de parámetros
if _lambda < 0:
raise ValueError('_lambda debe ser un valor numérico mayor a 0')
if alpha > 1 or alpha <= 0 or beta > 1 or beta <= 0:
raise ValueError('alpha y beta deben ser valores numericos entre (0,1]')
if not isinstance(limites, tuple) or len(limites) != 4:
97
raise ValueError('limites debe ser una tupla de 4 numeros')
(xmin, xmax, ymin, ymax) = limites
if xmin > xmax:
raise ValueError('En limites, xmin no puede ser mayor a xmax')
if ymin > ymax:
raise ValueError('En limites, ymin no puede ser mayor a ymax')
# numero de puntos con la distribucion de Poisson con una intensidad
proporcional al área
area = (xmax - xmin) * (ymax - ymin)
nnodos = stats.poisson.rvs(_lambda * area)
#nnodos = 20 ## Quitando el comentario se puede definer la cantidad de nodos
de manera manual.
# Obtenido el numero de puntos, se distribuyen los nodos de manera uniforme
nd_coord = np.random.uniform(size=(nnodos, 2))
nd_coord[:,0] = nd_coord[:,0] * ((xmax - xmin) + xmin)
nd_coord[:,1] = nd_coord[:,1] * ((ymax - ymin) + ymin)
## creacion de la matriz con todas las posibles distancias
x_rep = np.tile(nd_coord[:, 0], [1, nnodos]);
y_rep = np.tile(nd_coord[:, 1], [1, nnodos]);
dist_matr =sp.coo_matrix( np.triu(((x_rep-x_rep.transpose())**2 + (y_repy_rep.transpose())**2)**0.5, 1))
98
## creacion de la matriz de probabilidades
prob_matr = alpha*(-dist_matr /(beta * dist_matr.max()))
dist_matr = dist_matr.astype('Int32').max()
## generar la matriz de adyacencia
runi = sp.rand(1,dist_matr,1).max()
adj_matr = (runi>0) and (runi < prob_matr)
matplotlib.rcParams['axes.unicode_minus'] = False
fig, ax = plt.subplots()
ax.plot(nd_coord[:, 0], nd_coord[:, 1], 'o')
ax.set_title('modelo waxman')
plt.show()
topo = waxman( nnodos)
99
