IMPLEMENTACIÓN DE UN GENERADOR DE TOPOLOGÍAS...

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



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.


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.


4

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.

5

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.

6

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

7

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

8

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

9

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

10

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

11

LISTADO DE TABLAS

Tabla 1. Equipos Cómputo .................................................................................... 63

Tabla 2. Costos Administrativos............................................................................. 63

Tabla 3. Presupuesto de Inversiones ..................................................................... 64

12

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

13

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.

14

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.

15

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.

16

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).

http://www.cs.bu.edu/brite/user_manual/node48.html#Z01

17

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.

18

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)

http://sdnacademy.com/

19

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)

20

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)

21

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

22

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

23

“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)

24

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.

25

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)

26

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.

27

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. Puerto de entrada del conmutador 2. Dirección fuente MAC 3. Dirección destino MAC 4. Tipo Ethernet 5. VLAN 6. Dirección IP origen 7. Dirección IP destino 8. Puerto TCP/UDP origen 9. 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)

http://yuba.stanford.edu/cs244wiki/index.php/Overview

28

Ilustración 3. Funciones de Switch

Fuente:

https://www.academia.edu/5730624/Emulaci%C3%B3n_de_una_red_definida_por


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

29

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 ICMP5 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:

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)

5 Internet Control Message Protocol 6 Ping Request Message

30

Esquema básico de un controlador en la red:

Ilustración 4. Esquema básico de un controlador de red

Fuente:



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.

31

Diagrama de flujo de las funciones de un Controlador

Ilustración 5. Diagrama de flujo de las funciones de un controlador

Fuente:



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:

32

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.

http://mininet.org/

33

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 Gbps7, 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 8 Network Address Translation 9 Local Area Network 10 Proportional–Integral–Derivative

34

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 ifconfig-a, 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.

35

Topología de red simulada

Ilustración 7. Topologia de Red simulada

Fuente:http://es.slideshare.net/wavelasq/emulacin-de-una-red-definida-por-software-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)

36

Ilustración 8. Ejemplo simulacion Mininet

Fuente: https://www.academia.edu/5730624/Emulaci%C3%B3n_de_una_red_definida_por


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.

http://www.mininet.org/

37

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

38

API de nivel medio: Objeto de Red

Ilustración 10. Objeto de red


API de alto nivel: las plantillas de topología

Ilustración 11. Plantilla de topología


39

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.

40

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/

41

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 binomial:

.

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)

42

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:

43

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.

44

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

vértice es: 3(𝑘−1)

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

45

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.

46

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).

47

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)

48

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)

49

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

50

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)

51

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:

52

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


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

53

Ilustración 22. Validación de ingreso de datos


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


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


54

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


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.

55

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


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


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.

56

Ilustración 28. Coordenadas del Vector


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


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:

57

Ilustración 30. Matriz de probabilidades


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


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.

58

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


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


Recibiendo la cantidad de nodos se realiza la asignación de los host, links y switches por medio de un ciclo “FOR”.

59

Ilustración 34. Definición nodos y asignación host


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


60

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


O como:

Ilustración 37. Otro Ejemplo ejecución topología


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:

61

Ilustración 38. Ejecución Waxman.py


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.

62

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.

63

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 $ 720,000

Papelería $ 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.

64

Tabla 3. Presupuesto de Inversiones

PRESUPUESTO DE INVERSIONES

CONCEPTO DISTRIBUCIÓN

PRODUCC. ADMON. VENTAS

CAPITAL DE TRABAJO $ 6.000.000 $ - $ - $ -

Costos y Gastos Efectivos $ 820.000 $ - $ - $ -

Equipos $ 4.600.000 $ - $ - $ -

TOTAL INVERSIONES $ 5.420.000 $ - $ - $ -

PARTICIPACION POR ÁREA 100.0% 0.0% 0.0% 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.

65

10. CRONOGRAMA

Ilustración 39. Cronograma


66

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.

67

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-in-

python

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://cecilia-

urbina.blogspot.com.co/2013/04/topologias-y-ruteos.html

Community, T. S. (2008-2014). Scipy.org. Retrieved from http://docs.scipy.org/doc/scipy-

0.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-point-

processes/

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-personalizar-

python.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.

68

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


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

69

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/Lecture-

2-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-python-

xref.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-have-

equivalent-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/

70

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


Org Cython. (n.d.). Cython C-Extensions for Python. Retrieved from http://cython.org/

Paper, O. W. (2012). Open Networking Foundation. Retrieved from


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/

71

Read filesin Python. (2015). Retrieved from http://stackoverflow.com/questions/874461/read-

mat-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/scipy-


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/boletines-

a.php?id=0000140

Stack Over Flow. (2012). Retrieved from http://stackoverflow.com/questions/10555593/random-

adjacency-matrix-with-variation-on-number-of-edges-per-node

Stack Over Flow. (2012). Retrieved from http://stackoverflow.com/questions/2180299/range-of-

pythons-random-random-from-the-standard-library

The IPython Development, T. (n.d.). IP [y]. Retrieved from IP [y]: https://ipython.org/ipython-

doc/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-y-

configurar-wireshark-en-linux/

72

Vaamonde, S. R. (2013). De Matlab a Python. Retrieved from

https://srodriguezv.wordpress.com/2013/07/14/de-matlab-a-python-python-como-

lenguaje-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:



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/

73

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-in-

python

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://cecilia-

urbina.blogspot.com.co/2013/04/topologias-y-ruteos.html

Community, T. S. (2008-2014). Scipy.org. Retrieved from http://docs.scipy.org/doc/scipy-


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-point-

processes/

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-personalizar-

python.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.

74

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.





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

75

Jupyter Notebook Viewer. (2015). Retrieved from

http://nbviewer.ipython.org/github/gfrubi/clases-python-cientifico/blob/master/Lecture-

2-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-python-

xref.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-have-

equivalent-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/

76

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


Org Cython. (n.d.). Cython C-Extensions for Python. Retrieved from http://cython.org/

Paper, O. W. (2012). Open Networking Foundation. Retrieved from


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/

77

Read filesin Python. (2015). Retrieved from http://stackoverflow.com/questions/874461/read-

mat-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/scipy-


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/random-

adjacency-matrix-with-variation-on-number-of-edges-per-node

Stack Over Flow. (2012). Retrieved from http://stackoverflow.com/questions/2180299/range-of-

pythons-random-random-from-the-standard-library

The IPython Development, T. (n.d.). IP [y]. Retrieved from IP [y]: https://ipython.org/ipython-

doc/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-y-

configurar-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-como-

lenguaje-de-programacion-cientifico-y-tecnico/

78

Vargas, W. A. (2013). Emulacion de una red definida por software. Retrieved from Emulacion de

una red definida por software:



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/

79

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


80

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


Una vez que tenga el árbol de fuentes, el comando para instalar MiniNet es:

mininet/util/install.sh –a

Ilustración 42. Instalar Mininet


-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


81

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


$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


82

$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


sudo mn --topo tree,N

Crea una topología en árbol de N host y N switches.

Ilustración 47. sudo topo tree


83

COMANDOS DE PRUEBAS

Mininet>link [node1][node2][up o down]

Crea o elimina un o link entre dos nodos.

Ilustración 48. link


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


Mininet>pingall

Prueba conectividad entre dos nodos.

Ilustración 50. pingall


84

Mininet>pinpair

Realiza un test de conectividad entre las diferentes parejas de host de la red.

Ilustración 51. pingpair


Mininet>iperf

Comando para la caracterización del ancho de banda entre host.

Ilustración 52. iperf


Mininet>nodes

Muestra los nodos de la topología.

Ilustración 53. nodes


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


85

Mininet>net

Con este comando se muestra como están conectados los dispositivos de la red.

Ilustración 55. net


Mininet>eof

Detiene los dispositivos de la red y la cierra.

Ilustración 56. eof


Mininet>s(número del switch) arp

Comando para el protocolo de resolución de direcciones.

Ilustración 57. s1 arp


86

Mininet> h(número del host) ifconfig

Muestra la configuración de la interfaz del host

Ilustración 58. h1 if config


Mininet> s(número del switch) ifconfig

Muestra la configuración de la interfaz del switch.

Ilustración 59. s1 ifconfig


87

Mininet>h(número del host) ps

Imprime la lista de procesos a partir de un proceso de hosts.

Ilustración 60. h1 ps


Mininet>s(número del switch) ps

Imprime la lista de procesos del switch.

Ilustración 61. s1 ps


COMANDOS FUNCIONALES

Mininet>exit

Salir de Mininet

Ilustración 62. exit


88

Mininet>help

Ayuda, muestra lista de comandos de Mininet

Ilustración 63. help


Sudo su

Entrar en modo privilegiado

Ilustración 64. sudo su


89

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: ns-2, 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


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


http://www.omnetpp.org/

http://jfed.iminds.be/

90

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 ipython-notebook ipython-qtconsole sudo apt-get -y -q install python-dev python-scipy python-numpy python-matplotlib python-networkx python-gnuplot python-mako python-nose (github, s.f.)

Ilustración 67. Instalación librerías


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.)

https://docs.python.org/3/library/distutils.html#module-distutils

http://docs.cython.org/src/tutorial/external.html

91

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

http://www.gnuplot.info/

http://www.gnuplot.info/

92

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


Para abrir el archivo python desarrollado escribimos sudo python Waxman.py

Ilustración 70. Abrir archivo python Waxman.py


93

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


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


94

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


Seguimos los pasos indicados en la parte inferior para buscar y abrir el archivo correspondiente:

Ilustración 74. Modificación de archivo desde nano


Como último paso guardamos el archivo en la ruta especificada al momento de almacenar.

95

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).

96

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

97

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:

98

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_rep-y_rep.transpose())**2)**0.5, 1))

99

## 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)

IMPLEMENTACIÓN DE UN GENERADOR DE TOPOLOGÍAS...

Documents

Transcript of IMPLEMENTACIÓN DE UN GENERADOR DE TOPOLOGÍAS...