UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA La Universidad Católica de Loja ÁREA TÉCNICA TÍTULO DE INGENIERO EN SISTEMAS INFORMÁTICOS Y COMPUTACIÓN Análisis de Grafos en paralelo mediante Graphx TRABAJO DE TITULACIÓN AUTOR: Rodríguez Bautista, Daniel Ignacio. DIRECTOR: López Vargas, Jorge Afranio, Ing. LOJA – ECUADOR 2016 i Esta versión digital, ha sido acreditada bajo la licencia Creative Commons 4.0, CC BY-NYSA: Reconocimiento-No comercial-Compartir igual; la cual permite copiar, distribuir y comunicar públicamente la obra, mientras se reconozca la autoría original, no se utilice con fines comerciales y se permiten obras derivadas, siempre que mantenga la misma licencia al ser divulgada. http://creativecommons.org/licenses/by-nc-sa/4.0/deed.es Septiembre, 2016 APROBACIÓN DEL DIRECTOR DEL TRABAJO DE TITULACIÓN Ingeniero. Jorge Afranio López Vargas. DOCENTE DE LA TITULACIÓN De mi consideración: El presente trabajo de fin de titulación: Análisis de grafos en paralelo mediante GraphX, realizado por Daniel Ignacio Rodríguez Bautista, ha sido revisado y orientado durante su ejecución, por cuanto se aprueba la presentación del mismo. Loja, marzo del 2016. f)…………………………………… Ing. Jorge Afranio López Vargas C.I.: ii DECLARACIÓN DE AUTORÍA Y CESIÓN DE DERECHOS ―Yo, Daniel Ignacio Rodríguez Bautista, declaro ser autor del presente trabajo de titulación: ‗Análisis de grafos en paralelo mediante GraphX‘, de la Titulación de Sistemas Informáticos y Computación, siendo el Ing. Jorge Afranio López Vargas director del presente trabajo; y eximo expresamente a la Universidad Técnica Particular de Loja y a sus representantes legales de posibles reclamos o acciones legales. Además certifico que las ideas, conceptos, procedimientos y resultados vertidos en el presente trabajo investigativo, son de mi exclusiva responsabilidad. Adicionalmente declaro conocer y aceptar la disposición del Art. 88 del Estatuto Orgánico de la Universidad Técnica Particular de Loja que en su parte pertinente textualmente dice: ―Forman parte del patrimonio de la Universidad la propiedad intelectual de investigaciones, trabajos científicos o técnicos y tesis de grado o trabajos de titulación que se realicen con el apoyo financiero, académico o institucional (operativo) de la Universidad‖. f)…………………………………………….. Autor: Daniel Ignacio Rodríguez Bautista C.I.: 0802938795 iii DEDICATORIA El presente trabajo va dedicado primeramente a Dios porque él es mi mentor principal, y cada logro en mi vida se lo debo primeramente a él. En segundo lugar se lo dedico a mis padres y a mi hermano menor quienes siempre desearon verme realizar mis sueños, para quienes mi éxito se constituye en una gran alegría, a ellos dedico este logro y los resultados positivos que repercutan en consecuencia. A Irene, quien ha sido mi inspiración y quien siempre me ha levantado el ánimo, le dedico este trabajo con mucho cariño y ansioso de poder disfrutar con ella también del fruto de mi esfuerzo. A toda la gente que siempre creyó en mí, y a los que no creían en mí pero luego se dieron cuenta de que sí era capaz, también para ellos va dedicado este logro. iv AGRADECIMIENTO Mi agradecimiento primeramente al Altísimo, a mi Señor Jesús que es de quien viene la sabiduría y el conocimiento, y es quien me ha capacitado durante todo mi proceso y en todas las áreas de mi vida. En segundo lugar a mis padres y también a mi hermano, por su confianza en mí y por su apoyo incondicional en el aspecto moral, psicológico, económico, espiritual, etc. Además porque fueron quienes me formaron con valores cristianos y morales lo cual me ha llevado al éxito en todo, y siempre están orando por mí lo cual es el mayor respaldo que una persona pueda tener, aunque no los tenga cerca. También quiero darle las gracias a Irene, quien ha sido un pilar fundamental para yo poder salir adelante, ha suplido muchas necesidades en mí y me ha dado siempre su apoyo, recordándome siempre quién soy, y quién está conmigo, diciéndome siempre que soy capaz y estando a mi lado en las buenas y en las malas. Finalmente quiero darle las gracias a mi director de tesis, a quien admiro y respeto, y cuya actitud y frontalidad me llevaron muchas veces a reflexionar sobre mis errores y me enseñaron a ser mucho mejor de lo que podría estar siendo hasta determinados momentos; siempre me llevó a hacer más allá de lo que creía que podía hacer. Y a todos mis demás familiares, hermanos en Cristo y amigos, buenos y malos, todos fueron parte de mi formación, unos más que otros, pero son quienes complementan mi vida y en su mayoría me han dado ese impulso para conseguir mis sueños. v ÍNDICE DE CONTENIDOS APROBACIÓN DEL DIRECTOR DEL TRABAJO DE TITULACIÓN ........................... ii DECLARACIÓN DE AUTORÍA Y CESIÓN DE DERECHOS....................................... iii DEDICATORIA ............................................................................................................ iv AGRADECIMIENTO ..................................................................................................... v ÍNDICE DE CONTENIDOS .......................................................................................... vi RESUMEN.................................................................................................................... 1 ABSTRACT .................................................................................................................. 2 INTRODUCCIÓN .......................................................................................................... 3 CAPÍTULO 1: ESTADO DEL ARTE ............................................................................. 5 1.1 Introducción......................................................................................................... 6 1.2 Big Data. ............................................................................................................. 6 1.2.1 Movimiento NoSQL. ................................................................................................. 8 1.2.2 ¿Qué tipo de datos se debe explorar? .................................................................. 9 1.3 Análisis de Redes Sociales (SNA: Social Network Analysis). ............................ 10 1.3.1 Niveles de análisis. ................................................................................................. 12 1.4 Procesamiento de grafos. .................................................................................. 13 1.4.1 Grafos Dirigidos ...................................................................................................... 14 1.4.2 Grafos Conexos y Componentes ......................................................................... 15 1.4.3 Herramientas para el Procesamiento de Grafos. .............................................. 15 1.4.3.1 Apache Giraph ................................................................................................. 15 1.4.3.2 GraphLab PowerGraph .................................................................................. 16 1.4.3.3 PowerLyra ........................................................................................................ 16 CAPÍTULO 2: CONCEPTOS BÁSICOS ..................................................................... 18 2.1 Bases de datos orientadas a grafos ................................................................... 19 2.1.1 Ventajas y desventajas de una BDOG................................................................ 20 2.1.2 Modelos de datos en Grafo................................................................................... 21 2.2 Computación Paralela ....................................................................................... 23 2.2.1 Clasificación de los sistemas paralelos. ............................................................. 23 2.2.2 Clúster. ..................................................................................................................... 27 2.3 Spark. ................................................................................................................ 29 2.3.1 Resilient Distributed Dataset. ............................................................................... 29 2.3.2 Spark SQL. .............................................................................................................. 30 2.3.3 Spark Streaming. .................................................................................................... 31 2.3.4 Machine Learning Library (MLlib). ....................................................................... 31 2.3.5 GraphX. .................................................................................................................... 32 vi 2.4 Tecnologías asociadas ...................................................................................... 34 2.4.1 Scala. .................................................................................................................. 35 2.4.2 SBT (Simple Build Tools). ............................................................................... 35 2.4.3 JDK (Java Development Kit)........................................................................... 36 2.4.4 Apache Maven. ................................................................................................. 36 CAPÍTULO 3: INSTALACIÓN, CONFIGURACIÓN Y DESPLIEGUE DE SPARKGRAPHX .................................................................................................................... 37 3.1 Instalación de Spark .......................................................................................... 38 3.2 Spark Standalone Clúster .................................................................................. 39 3.3 Hadoop YARN. .................................................................................................. 44 3.3.1 Spark sobre YARN. ................................................................................................ 48 3.4 Análisis de grafos con GraphX .......................................................................... 49 CAPÍTULO 4: MÉTRICAS DEL SNA – GRAPHX ...................................................... 51 4.1 Métricas del SNA............................................................................................... 52 4.1.1 Centralidad de Grado (Degree Centrality). ......................................................... 52 4.1.2 Centralidad de Intermediación (Betweenness Centrality). .............................. 52 4.1.3 Centralidad de Cercanía (Closeness Centrality). ............................................. 53 4.1.4 Centralidad Vector Propio. .................................................................................... 53 4.1.5 Coeficiente de agrupamiento. ............................................................................... 53 4.1.6 Densidad. ................................................................................................................. 53 4.2 SNA – GraphX................................................................................................... 54 4.2.1 Casos de aplicación. .............................................................................................. 55 CONCLUSIONES ....................................................................................................... 57 RECOMENDACIONES............................................................................................... 59 BIBLIOGRAFÍA .......................................................................................................... 61 ANEXOS .................................................................................................................... 63 ANEXO A: INSTALACIÓN DE SBT. ........................................................................ 64 ANEXO B: INSTALACIÓN DE SCALA. ................................................................... 65 ANEXO C: INSTALACIÓN DE MAVEN. .................................................................. 66 ANEXO D: INSTALACIÓN DE JDK. ........................................................................ 67 ANEXO E: APLICACIÓN DE EJEMPLO – GRAPHX............................................... 72 ANEXO F: CAPTURAS GRAPHX ........................................................................... 73 ANEXO G: DESPLIEGUE DE GRAPHX SOBRE STANDALONE-CLUSTER.......... 75 ANEXO H: CONFIGURACIÓN DE YARN SINGLE-NODE. ..................................... 81 vii RESUMEN El manejo de información expresada en grafos es una de las tendencias actuales, gracias a la popularidad de redes sociales online, diariamente se genera grandes volúmenes de los datos, lo que provoca que las técnicas tradicionales de procesamiento se vean limitadas. Dentro del procesamiento de grandes volúmenes de datos o Big Data ha empezado a surgir una alternativa a Map/Reduce llamada Spark, que cuenta con una librería para el procesamiento distribuido de grafos. El presente proyecto de fin de titulación busca explorar las capacidades de procesamiento de grafos en paralelo, de una de las tecnologías más actuales de clustering computing llamada Spark, específicamente de su librería para el procesamiento de grafos en paralelo denominada ―GraphX‖. PALABRAS CLAVES: Grafos, Redes sociales, Big Data, Spark, Graphx, Clusterig computing. 1 ABSTRACT The management information expressed in graph is one of the current trends, thanks to the popularity of online social networks daily large volumes of data are generated, which causes traditional processing techniques look limited. Within the processing of large volumes of data or big data it has begun to emerge an alternative to Map/Reduce called Spark , which has a library for distributed processing graph. This project seeks to explore the capabilities degree of processing graphs in parallel, one of the latest clustering computing technologies called Spark, specifically its library for parallel graph processing called ―GraphX‖. KEYWORDS: Graphs, Social Network, Big Data, Spark, Graphx, Clusterig Computing. 2 INTRODUCCIÓN El tema desarrollado para este trabajo de fin de titulación consiste en la implementación de una de las herramientas de Big Data, una librería de Apache Spark llamada Graphx para el procesamiento de grafos en paralelo. Este trabajo de titulación pretende instalar, configurar y determinar qué métricas del SNA se pueden aplicar usando Spark-Graphx, sobre más de una plataforma. A través de los capítulos se tendrá un acercamiento a lo que es Big Data, qué procesos sigue y en dónde se ubica el presente tema de tesis. Además se podrá conocer en detalle los aspectos más relevantes de Spark – Graphx, los componentes que requiere para construirse la implementación de un clúster para el procesamiento de grafos en paralelo y algunas recomendaciones y mejores prácticas para su uso. La importancia de este trabajo radica en el hecho de que actualmente la información crece desmesuradamente, y las herramientas conocidas para su tratamiento empiezan a verse limitadas; es por ello que surge la necesidad de buscar nuevas alternativas, nuevas soluciones, y herramientas como ésta dan respuesta a muchas necesidades que las tecnologías tradicionales no. La solución al problema planteado se dio gracias a una investigación intensiva, revisión bibliográfica, ejecutando un sin número de pruebas hasta llegar a la solución definitiva. Todo lo conseguido hasta el momento se ha documentado para a partir de allí poder continuar con la investigación. Cabe señalar que la solución detallada se puede mejorar, queda a criterio del interesado abocarse a esta tarea. 3 Objetivo general Explorar las capacidades de procesamiento de grafos en paralelo de GraphX. Objetivos específicos Implementar Spark y su librería para el procesamiento de grafos en paralelo GraphX (multiplataforma, en Linux y Mac OS); para poder establecer una instalación y configuración limpia de esta tecnología, determinar ventajas y desventajas de su instalación en cada plataforma, y por último, observar su comportamiento realizando algunas iteraciones, con variaciones en el hardware asignado para el clúster y los datasets a analizar. Implementar un cluster manager para realizar el procesamiento en paralelo. Construir un grafo en GraphX y determinar qué métricas del SNA se pueden aplicar sobre el mismo. 4 CAPÍTULO 1: ESTADO DEL ARTE 5 1.1 Introducción Es importante saber lo que el mundo está haciendo con respecto al análisis de datos expresados en grafo, para de esta manera poder tener clara la perspectiva desde la cual se abordará el presente tema de tesis. Existe una variedad de técnicas y herramientas para realizar este trabajo, cada una con su particularidad, pero con el transcurso del tiempo la información ha ido creciendo mucho más rápido de lo que estas técnicas y herramientas han ido evolucionando, y el coste de implementación de grandes infraestructuras para realizar este tipo de procesamiento también se ha incrementado. Sin embargo, en los últimos años la ciencia ha ido reaccionando más rápido a los estímulos provocados por Big Data y ha desarrollado herramientas que no solo optimizan el procesamiento, sino también la utilización de hardware. En esta sección se verán algunos aspectos referentes al origen del procesamiento de grafos, el concepto que lo engloba y algunas herramientas útiles para realizar esta tarea. 1.2 Big Data. Big Data es un concepto que está muy de moda y que a lo largo del tiempo se ha ido expandiendo. Básicamente consiste en la manipulación de grandes cantidades de información, lo que implica una alta demanda de hardware e infraestructura tecnológica. Este fenómeno ha ocasionado que las herramientas convencionales de gestión de datos (como las bases de datos relacionales) se vean cada vez más limitadas a la hora de gestionar estas gigantescas cantidades de información (petabytes de información), que cada día se genera a mayor velocidad y en mayores cantidades; esto ha generado la búsqueda de nuevas alternativas, nuevas maneras de almacenar y procesar los datos; una de las alternativas que surgió recibió el nombre 6 de NoSQL, que es un movimiento del cual se hablará más adelante, que ofrece varias alternativas para el almacenamiento de los datos; a más de eso, en la actualidad se han desarrollado diversas herramientas para el procesamiento de dicha información. El Grupo TRC1 (Grupo TRC, s.f.) sostiene que Big Data: Es una definición utilizada en tecnología para referirse a la información o grupo de datos que por su elevado volumen, diversidad y complejidad no pueden ser almacenados ni visualizados con herramientas tradicionales. Las dimensiones de estos datos obligan a las empresas a buscar soluciones tecnológicas para gestionarlos, pues un buen manejo del Big Data puede representar nuevas métodos para la toma de decisiones y oportunidades de negocio. Las principales técnicas de Big Data comprenden la captura y análisis de la información, estructurada, semi-estructurada y no estructurada, la misma que se produce por medio de las redes sociales, páginas web, dispositivos móviles, correos electrónicos, videos, notas de voz, archivos de texto, etc., luego la minería de datos (para su análisis), y la visualización de la información. Existen tres conceptos clave relacionados con Big Data: Volumen. Variedad. Velocidad. Volumen.- Se refiere al tamaño de la información. ―En el año 2012, la cantidad de información en el universo digital llegó a 2.8 zettabytes (ZB); según un informe de la consultora IDC Digital Universe para el año 2020 se podrían alcanzar los 40 ZB de datos generados por personas y dispositivos.‖ (IDATHA, 2014) Variedad.- ―Estructurados o no, los datos pueden provenir de diversas fuentes y formas. Imágenes, videos, tweets, etiquetas RFID, historias clínicas, sensores de movimiento, etcétera.‖ (IDATHA, 2014) Velocidad.- ―La velocidad en el acceso y el flujo de datos es el gran reto que plantea Big Data no solo hoy, sino también —y sobre todo— de cara al futuro.‖ (Lantares, s.f.) 1 TRC es una empresa española que ocupa un puesto de liderazgo en soluciones globales de telecomunicaciones y servicios TI. En el año 2013 se consolida la asociación entre TRC y GNET, a dicha asociación se le denominó como “Grupo TRC”. 7 1.2.1 Movimiento NoSQL. Las bases de datos NoSQL (Not only SQL) ―son sistemas de almacenamiento de información que no cumplen con el esquema entidad-relación tradicional, es decir, no imponen una estructura de datos en forma de tablas y relaciones entre ellas.‖ (Nasca, 2014) Las bases de datos relacionales tradicionales permiten definir la estructura de un esquema que demanda reglas rígidas que garantizan ACID: - Atomicy. - Consistency. - Isolation. - Durability. Pero ―las aplicaciones web modernas presentan desafíos muy distintos a los que presentan los sistemas empresariales tradicionales (ej. sistemas bancarios): - Datos a escala web. - Alta frecuencia de lecturas y escrituras. - Cambios de esquemas de datos frecuentes.‖ (Ipiña, 2012) Las principales características de los sistemas NoSQL son: Estructura dinámica: ―Los datos no tienen una definición de atributos fija, es decir, cada registro puede contener información con diferente forma cada vez, pudiendo así almacenar solo los atributos que interesen en cada uno de ellos.‖ (Nasca, 2014) Tolerancia a fallos y redundancia. Alta velocidad: ―Estos sistemas realizan operaciones directamente en memoria y solo vuelcan datos al disco cada cierto tiempo. Esto permite que las operaciones de escritura sean realmente rápidas.‖ (Nasca, 2014) Los diferentes tipos de bases de datos NoSQL son: Key-Value (Clave-Valor). Documental (Basada en documentos). Orientada a Columnas. Orientadas a Grafos. Algunas opciones de NoSQL disponibles en la actualidad son: Cassandra, MongoDB, CouchDB, Jackrabbit, Neo4j, BigTable, Riak y Dynamo. 8 1.2.2 ¿Qué tipo de datos se debe explorar? ―Muchas organizaciones se enfrentan a la pregunta sobre ¿qué información es la que se debe analizar?, sin embargo, el cuestionamiento debería estar enfocado hacia ¿qué problema es el que se está tratando de resolver?‖ (IBM, 2012) Existen muchos tipos de datos que se pueden analizar, la figura 1 muestra una clasificación que ayudará a comprender de mejor manera la representación de los datos. Figura 1. Clasificación de los tipos de datos. Fuente: Recuperado de: https://goo.gl/RSQfLm Web and Social Media: Información obtenida de las redes sociales, como Twitter, Facebook, Instagram, entre otras, y páginas web en general. Biometrics: Información biométrica como huellas digitales, escaneo de retina, reconocimiento facial, etc. Machine to Machine: Corresponde a información que se crea gracias a tecnologías que permiten que un dispositivo se comunique con otro 9 directamente, ya sea para transmitir o recibir señales percibidas por sensores o medidores. Big Transaction Data: Este tipo de información se refiere a registros de facturación, registros de llamadas telefónicas, y todo tipo de datos transaccionales en general. Human Generated: Es la información que generamos los seres humanos, como documentos, archivos de video, notas de voz, mensajes de texto, etc. (IBM, 2012) 1.3 Análisis de Redes Sociales (SNA: Social Network Analysis). El análisis de redes sociales es un tema que, a pesar de no ser tan reciente, sigue estando en auge. Su objetivo se enfoca en el análisis de actores y sus relaciones con otros actores. Cada actor está representado como un nodo perteneciente a un grafo, que tiene uno o más vínculos con otros nodos. De acuerdo a lo que sostiene Luis Sanz Menéndez (Menéndez, 2003) ―El análisis de redes sociales ARS (social network analysis), también denominado análisis estructural, se ha desarrollado como herramienta de medición y análisis de las estructuras sociales que emergen de las relaciones entre actores sociales diversos (individuos, organizaciones, naciones, etc.)‖. Éste se apoya en métricas que se pueden aplicar sobre un grafo (ver capítulo 4), para determinar la manera en que los actores se relacionan e interactúan, cómo se comunican, cuál es el flujo de la información, qué tan agrupados están; a nivel de nodos, conocer cuál su ubicación dentro de la red, determinar qué tan bien posicionado está con respecto a los demás, etc. De acuerdo al INSNA (International Network for Social Network Analysis): El análisis de redes sociales se centra en el descubrimiento de los patrones de la interacción de las personas. Es sobre el tipo de patrón que Roger Brown describió cuando escribió: "La estructura social se hace visible en un hormiguero. Los movimientos y contactos que uno ve no son al azar, sino de forma modelada. También debe ser capaz de ver la estructura en la vida de una comunidad. Si tuviéramos un punto de vista suficientemente lejano, un punto desde el cual las personas parecieran puntos pequeños en movimiento, veríamos que estos puntos no se aproximan entre sí al azar, algunos por lo general siempre están juntos, algunos se reúnen a menudo, algunos nunca. Si 10 uno pudiera alejarse lo suficiente de ella, la vida humana se convertiría en modelo puro‖. (INSNA, s.f.) Ahora, es importante definir ¿qué es una red social? De acuerdo a lo que sostiene Mauricio Monsalve Moreno (Moreno, 2008) de la Universidad de Chile, ―Una red social es un conjunto de actores vinculados entre sí. Con esto hemos definido un grafo, pues tenemos los vértices y las aristas o, como le llaman los sociólogos, actores y vínculos.‖. La Figura 2 ilustra una pequeña red social en la que varios individuos se relacionan entre sí por una relación de ―amistad‖. Los vínculos pueden ser de cualquier tipo, ya sea de trabajo, amor, consanguineidad, etc. Figura 2. Red Social. Fuente: Recuperado de: http://goo.gl/oV6ANW. La pregunta es ¿por qué es necesario analizar o investigar las redes sociales? Hay varias razones, entre ellas destaca el interés por: 1. El estudio de La Web, que concierne directamente a la gente de ciencia de la computación. 2. El estudio de cómo se hace y mide la ciencia (scientometrics, epistemometria), que es de interés para gran parte de la comunidad científica. 3. Las ciencias sociales, ya que el análisis de redes sociales se utiliza activamente en sociología, antropología, ciencia política, gestión organizacional, medios de comunicación (social media analysis), etc. 4. La teoría de grafos y la matemática discreta, el fundamento técnico del análisis de redes sociales. 11 5. El modelamiento, la simulación y el diseño de algoritmos, habilidades y conocimientos clave que han hecho que el análisis de redes sociales escale en tamaño. (Menéndez, 2003) Existe una variedad de software para realizar esta tarea. Es importante mencionar que sin la existencia del software no sería posible completar muchos de estos avances tecnológicos. Entre los programas más destacados están: Egonet. Netdraw. Visone. Dynet. NetMiner. Pajek. Siena. Visone. Estos programas se utilizan para representar y analizar gráficas que se crean en base a una serie de datos previamente almacenados. 1.3.1 Niveles de análisis. En el SNA existen distintos niveles de análisis, dependiendo de dónde se focalice la atención dentro de la estructura de la red. Existen tres niveles de análisis dentro del SNA: I) el análisis de redes egocéntricas, II) el análisis focalizado en subgrupos de actores y III) el análisis focalizado en la estructura total de la red. Análisis de redes egocéntricas: En este nivel, el análisis se centra en un nodo clave al que se le denomina Ego, sus relaciones y comportamiento. Por ejemplo, imagine que se desea analizar a un mediador entre un político y el pueblo. Éste se encarga de gestionar las relaciones entre el pueblo (que brinda apoyo político con el fin de obtener un beneficio) y el político (que busca brindar beneficios a cambio de votos y apoyo político). El objetivo es analizar cómo el mediador (Ego) construye y modifica sus relaciones (hacia ―abajo‖ con el pueblo y hacia ―arriba‖ con el político), cómo aprovecha la posición 12 que ocupa, cómo se adapta a los cambios y en qué medida éstas relaciones impulsan o restringen sus intereses. Análisis de subgrupos de actores: En este nivel se analiza tres tipos de relaciones: o Redes diádicas, en las que se analiza un par de nodos y la intensidad y duración de sus vínculos, o Relaciones tríadicas, que involucran a tres actores interrelacionados, o Clústeres, que representan subgrupos dentro de la red. El análisis de este tipo de relaciones proporciona pautas claves sobre la lógica de agrupamiento de las redes y es útil para determinar la existencia de patrones de cooperación o de competencia. Análisis de la estructura total de la red: ―En este nivel, el énfasis está puesto en la estructura general de la Red (el nivel macro), considerando las particularidades morfológicas que adopta, la existencia, rol e interacción de subgrupos (clústeres), la distribución de las relaciones entre los actores involucrados, la distancia geodésica entre los actores, entre otros.‖ (Aguirre, 2011) 1.4 Procesamiento de grafos. “Graph analysis is the true killer app of Big Data” (Research, 2011) Figura 3. Arquitectura para la implementación de un motor de procesamiento de grafos. Fuente: Ian Robinson, Jim Webber & Emil Eifrem. Graph Databases 2nd Edition. Los grafos están en casi todo, por ejemplo en las redes sociales (Facebook, Twitter), en la ciencia, en el comercio (Amazon, Mercadolibre) y en la web en general 13 (Wikipedia, Google). Por ejemplo, es muy común que Facebook muestre ―personas que quizás conozca‖; generalmente aciertan y presentan amigos con los que seguramente hace mucho no se tenía contacto, la pregunta es ¿cómo supo Facebook que son sus conocidos? Pues por la estructura de datos que manejan, es decir, en grafos, sobre la cual se ha ejecutado un procesamiento. Debido a que se habla de millones o miles de millones de datos, se puede deducir que no existe un solo computador capaz de realizar dicho procesamiento, y es ahí donde nace la necesidad de ―distribuir‖ (paralelizar) el trabajo, para que la información sea analizada por lotes. Para ello han surgido muchas tecnologías, cada una con su particularidad y características que las hace a unas más convenientes que otras, según sea la necesidad. Con el pasar de los años la el crecimiento de la información se ha acelerado considerablemente, la información no solo crece, sino que crece a una velocidad impresionante, los datos generados por diversos tipos de fuentes (en especial por los humanos) se generan a millones por segundo; es por esto que las herramientas tradicionales de procesamiento de información se han visto limitadas, y cada vez se está buscando optimizar los tiempos de respuesta y el uso de hardware. Algunas de estas herramientas se verán más adelante. Pero, ¿cuál es la importancia de analizar esos ―petabytes‖ de datos? La respuesta radica en que los resultados obtenidos del análisis de estos datos pueden ayudar a predecir el comportamiento de las personas, la tendencia de los usuarios o su inclinación con respecto a diferentes tipos de productos, identificar oportunidades de negocio, sirven de soporte en la toma de decisiones, etc. 1.4.1 Grafos Dirigidos Stanley Wasserman y Katherine Faust (Stanley Wasserman, 2013, págs. 148, 149) sostienen que: 14 Una relación direccional se puede representar mediante un grafo dirigido. El grafo dirigido consiste en un conjunto de nodos que representan a los actores de una red, un conjunto de arcos dirigidos entre pares de nodos, que representan lazos dirigidos entre los actores. La diferencia entre un grafo y un grafo dirigido es que en un grafo dirigido se especifica la dirección de las líneas. Los lazos dirigidos entre pares de actores se representan como líneas en las que se especifica la orientación de la relación. 1.4.2 Grafos Conexos y Componentes Una característica importante de un grafo a tener en cuenta, es si está conectado o no. Un grafo está conectado si hay un camino entre cada par de nodos del grafo. Es decir, en un grafo conexo todos los pares de nodos son accesibles. Si un grafo no es conexo, entonces es disconexo o inconexo. Consideremos el ejemplo de las comunicaciones entre empleados de una organización. Si el grafo que representa las comunicaciones entre los empleados es conectado, entonces los mensajes pueden viajar desde cualquier empleado hasta todos y cada uno de los demás empleados a través de canales de comunicación por pares. Pero si el grafo que representa esta red es disconexo, entonces algún par de personas no pueden enviar o recibir mensajes entre ellos usando los canales de comunicación. (Stanley Wasserman, 2013) 1.4.3 Herramientas para el Procesamiento de Grafos. 1.4.3.1 Apache Giraph De acuerdo al sitio oficial de Giraph (The Apache Software Foundation, 2014): Apache Giraph es un sistema de procesamiento de grafos interactivo construido para una alta escalabilidad, pero se limita a un Hadoop Map/Reduce un poco lento. Su uso está actualmente aplicado en Facebook para analizar el 15 grafo de la red social formado por los usuarios y sus conexiones. Giraph se originó como la contraparte de código abierto para Pregel, la arquitectura de procesamiento gráfico desarrollado en Google. Ambos sistemas se inspiran en el modelo paralelo síncrona a granel de la computación distribuida introducido por Leslie Valiant. Giraph añade varias características más allá del modelo básico Pregel, incluyendo cómputo principal, agregadores fragmentados, entrada de borde orientada, fuera del núcleo de la computación, y más. Con un ciclo de desarrollo estable y una creciente comunidad de usuarios en todo el mundo, Giraph es una elección natural para liberar el potencial de los conjuntos de datos estructurados en una escala masiva. 1.4.3.2 GraphLab PowerGraph GraphLab es otro de los proyectos de gran alcance para el análisis de grafos en paralelo. El proyecto GraphLab PowerGraph consiste en una API de núcleo y una colección de herramientas de aprendizaje automático y minería de datos de alto rendimiento. La API está escrito en C++ y construido en el top de las tecnologías estándar de clúster y de computación en la nube. La comunicación entre procesos se lleva a cabo a través de TCP-IP y MPI se utiliza para poner en marcha y gestionar programas GraphLab PowerGraph. Cada proceso es multiproceso para aprovechar al máximo los recursos disponibles en varios núcleos de los nodos del clúster. Apoya la lectura y la escritura en tanto Posix y sistemas de archivos HDFS. (Dato-Code, s.f.) 1.4.3.3 PowerLyra PowerLyra se basa en la última base de código de GraphLab PowerGraph y puede soportar sin problemas todos los kits de herramientas GraphLab. PowerLyra ofrece varios nuevos motores de ejecución híbridos y algoritmos de 16 particionamiento para lograr un rendimiento óptimo mediante el aprovechamiento de las propiedades del grafo de entrada.2 PowerLyra integra Nuevas funciones: Motor de computación híbrido: Explota la localidad de vértices de bajo grado y el paralelismo de los vértices de alto grado. Algoritmo de particionamiento híbrido: Diferencia los algoritmos de partición para diferentes tipos de vértices. Estrategia de programación diversa: Proporcionar los dos motores de cálculo síncronas y asíncronas. API compatible: Soporta sin problemas todos los kits de herramientas GraphLab. (Chen, 2015) 2 Para más detalles ingrese a http://ipads.se.sjtu.edu.cn/projects/powerlyra.html. 17 CAPÍTULO 2: CONCEPTOS BÁSICOS 18 2.1 Bases de datos orientadas a grafos Las bases de datos orientadas a grafos (BDOG) son un tipo de almacenamiento NoSQL (ver sección 1.2.1), pensado para el almacenamiento de grandes cantidades de datos y están optimizadas para el procesamiento eficiente de grandes conjuntos de datos interrelacionados. Las BDOG, a diferencia de las bases de datos relacionales, almacenan los datos como nodos (vértices) y aristas (relaciones) entre ellos, es decir, cada dato es un nodo único que tiene atributos propios, y las relaciones a su vez tienen también atributos, esto facilita el análisis de las grandes cantidades de información. Figura 4. GraphDatabase PropertyGraph. Fuente: Recuperado de: https://goo.gl/OPMKNo. Las consultas en una BDOG siempre empiezan en un nodo específico, a partir del cual se exploran sus relaciones con otros nodos, de manera que para cada consulta no será necesario recorrer todo el grafo sino solo el tamaño de la parte del grafo que necesite recorrer para satisfacer la consulta, lo que acelera el tiempo de respuesta de las mismas. Entre las más populares están: - Neo4j. - Infinite Graph. 19 - InfoGrid. - HyperGraphDB. - Trinity. - *dex. Los componentes de una BDOG son: - Grafo: La Red en sí. - Nodos: Todos los actores miembros de la Red. - Relaciones: Los vínculos entre los actores. - Propiedades: Atributos de los actores; las relaciones también pueden tener sus propios atributos. 2.1.1 Ventajas y desventajas de una BDOG. Ian Robinson, Jim Webber y Emil Eifrem (Ian Robinson, 2015) afirman que: Una razón importante para el uso de bases de datos con grafos es su mayor rendimiento, en comparación con las bases de datos relacionales y otras NoSQL. A diferencia de las bases de datos relacionales, cuyos rendimientos se deterioran en las consultas intensivas y con un procesamiento de datos muy alto; las bases de datos con grafos ofrecen un rendimiento que tiende a permanecer constante, así como el crecimiento de los datos. Esto se debe a que las consultas se realizan de manera gráfica, recorriendo entre las relaciones (aristas) que posea la base. Como resultado, el tiempo de ejecución de esta consulta es proporcional solo al tamaño de la parte grafica que tenga que recorrer para satisfacer esta consulta, en lugar del tamaño global del grafo. Además de esto, Existen otras cualidades por las que muchas empresas muestran su interés por implementar este tipo de tecnologías: - Instalación simple. - Opensource. - Manejo de enorme cantidades de información, ya sea estructurada, semiestructurada o no estructurada. 20 - Rapidez para conectar los datos. En las bases de datos relacionales, el frecuente uso de joins hace que las búsquedas sean lentas. (Maribel Tirados, 2014) No obstante, el uso de este tipo de tecnologías también conlleva ciertos riesgos o desventajas, que hacen que también muchas empresas se detengan a pensar en si es conveniente o no implementarlas. Tales desventajas consideran aspectos como: - La tecnología no está lo suficientemente madura para algunas empresas: Debido a que es algo relativamente reciente, se puede considerar que no es totalmente confiable para el uso pleno en producción. - Requiere un cambio conceptual para los desarrolladores, lo que implica una curva de aprendizaje. - Problemas de compatibilidad: Las bases de datos relacionales generalmente comparten ciertos estándares, como por ejemplo el lenguaje de consultas; por su parte, las bases de datos en Grafo generalmente tienen sus propias APIs y sus propios lenguajes. (Nasca, 2014) 2.1.2 Modelos de datos en Grafo. Existen varios modelos de datos expresados en grafo, entre ellos están: Property Graph: Este término denota un grafo multi – relacional en donde sus nodos tienen cualquier número de atributos al igual que sus aristas. Este modelo facilita la especificación de múltiples relaciones entre dos nodos (por ejemplo, compañero de trabajo, amigo). El modelo de Grafo-Propiedad Etiquetada tiene ciertas características sobresalientes: Un Grafo-Propiedad marcado se compone de nodos, relaciones, propiedades y etiquetas. Los nodos contienen propiedades. Piense en los nodos como documentos que almacenan propiedades en la forma de pares clave-valor arbitrario. En Neo4j, las claves son cadenas y los valores son la cadena de Java y los tipos de datos primitivos, además de las matrices de estos tipos. 21 Los nodos pueden ser etiquetados con una o más etiquetas. Grupo de etiquetas nodos juntos, e indicar las funciones que desempeñan en el conjunto de datos. Relaciones conectan los nodos y estructuran el gráfico. Una relación siempre tiene una dirección, un solo nombre, y un nodo de inicio y fin de nodos no hay colgando relaciones. Juntos, la dirección y el nombre de una relación añaden claridad semántica a la estructuración de nodos. Al igual que los nodos, las relaciones también pueden tener propiedades. La posibilidad de agregar propiedades a las relaciones es particularmente útil para proporcionar metadatos adicionales para gráfica algoritmos, añadiendo semántica adicional a las relaciones (incluyendo la calidad y peso), y para limitar las consultas en tiempo de ejecución. (Ian Robinson, 2015) Un ejemplo de este modelo se muestra en la figura 5. Figura 5. Property Graph. Fuente: Recuperado de: http://goo.gl/dCQykB RDF: Es un modelo estándar para el intercambio de información en la web; esta estructura enlazada forma un grafo dirigido y marcado en donde las aristas representan las relaciones entre dos recursos (nodos o vértices). Hypergraph: Este modelo representa un grafo dirigido o no dirigido en el que una arista puede conectar un número arbitrario de vértices, lo que significa que un grafo puede ser tan solo un sub conjunto de un Hipergrafo. 22 2.2 Computación Paralela La computación paralela surgió por la necesidad de resolver problemas de gran magnitud, los cuales empezaban a escaparse del alcance de las computadoras. Gracias a ella es posible realizar grandes tareas de manera muy rápida y eficiente. La computación paralela o ―procesamiento en paralelo‖ consiste en la división o distribución de la ejecución de un programa, en diferentes lotes que serán analizados al mismo tiempo por diferentes procesadores. Esto se hace con el fin de acelerar el tiempo de procesamiento. En la computación paralela lo más importante es la comunicación, ya que los procesadores necesitan intercambiar información entre sí. Ésta se puede dar de dos formas: Se cuenta con una sola memoria a la cual pueden acceder todos los procesadores (memoria compartida), dicho de otra manera, se cuenta con un solo computador que tiene varios procesadores que comparten la memoria y los dispositivos de entrada y salida; estos procesadores pueden acceder a todos los módulos de memoria directamente. La otra manera se da teniendo dos o más computadoras (clúster), cada una con su memoria, con sus dispositivos de entrada y salida y con su procesador, las cuales se comunican entre sí por medio de una red de computadoras. La computación paralela se divide en tres partes: La primera consiste en dividir la tarea en partes pequeñas, la segunda consiste en asignar las tareas a los diferentes procesadores para que sean ejecutadas y la tercera parte tiene que ver con la comunicación, si no hay comunicación las tareas no pueden ser procesadas al mismo tiempo por los procesadores, de esta manera todo lo que está conectado coopera. 2.2.1 Clasificación de los sistemas paralelos. En el año de 1966 Michael J. Flynn estableció una clasificación general de los sistemas paralelos, basada en el flujo de instrucciones y el flujo de datos que en ellos se maneja. La clasificación de Flynn es la siguiente: SISD: Single Instruction Single Data (única instrucción, datos únicos). Este es un modelo secuencial que describe un sistema en el que se maneja una única 23 instrucción sobre un único flujo de datos. Este modelo secuencial es el propuesto por Von Neuman en el que en cualquier instante se puede estar ejecutando una sola instrucción. Figura 6. Modelo SISD. FUENTE: Recuperado de: http://goo.gl/PY1D4i. SIMD: Single Instruction Multiple Data (única instrucción, múltiples datos). Este modelo describe un sistema en el que se tiene varias unidades de procesamiento trabajando sobre flujos de datos distintos, pero ejecutando la misma instrucción. El enfoque de paralelismo usado aquí se denomina paralelismo a nivel de datos. Todos los procesadores trabajan con una perfecta sincronización. SIMD hace un uso eficiente de la memoria, y facilita un manejo eficiente del grado de paralelismo. La gran desventaja es el tipo de procesamiento (no es un tipo de procesamiento que aparece frecuentemente), ya que el código debe tener una dependencia de datos que le permita descomponerse. (J. Aguilar, 2004) 24 Figura 7. Modelo SIMD. Fuente: Recuperado de: http://goo.gl/PY1D4i. MISD: Multiple Instruction Single Data (mútiples instrucciones, datos únicos). En este modelo de sistemas se ejecutan varios flujos de instrucciones al mismo tiempo, actuando todos ellos sobre el mismo conjunto de datos. Jose Aguilar y E. Leiss concluyen que “la idea es descomponer las unidades de procesamiento en fases, en donde cada una se encarga de una parte de las operaciones a realizar. De esta manera, parte de los datos pueden ser procesados en la fase 1 mientras otros son procesados en la 2, otros en la tres, y así sucesivamente.” (J. Aguilar, 2004) 25 Figura 8. Modelo MISD. Fuente: Recuperado de: http://goo.gl/PY1D4i. MIMD: Multiple Instructions Multiple Data (múltiples instrucciones, múltiples datos). En este modelo de sistemas se tienen varias unidades de proceso, cada una con un conjunto de datos asociado y ejecutando un flujo de instrucciones distinto. Es el modelo más general de paralelismo, y debido a su flexibilidad, una gran variedad de tipos de paralelismo pueden ser explotados. Las ideas básicas son que múltiples tareas heterogéneas puedan ser ejecutadas al mismo tiempo, y que cada procesador opere independientemente con ocasionales sincronizaciones con otros. Está compuesto por un conjunto de elementos de procesamiento donde cada uno realiza una tarea, independiente o no, con respecto a los otros procesadores. (J. Aguilar, 2004) 26 Figura 9. Modelo MIMD. Fuente: Recuperado de: http://goo.gl/PY1D4i. En el análisis de grafos en paralelo el modelo que se usa es el SIMD, ya que existe un conjunto de datos separados por lotes, sobre los cuales se ejecuta la misma instrucción al mismo tiempo. 2.2.2 Clúster. Un clúster es un tipo de arquitectura paralela distribuida, que consiste de un conjunto de computadores interconectados operando de forma conjunta como un único computador, cuyas prestaciones son mucho más altas que las de cualquier ordenador. La arquitectura básica de un clúster computacional consta de un ―máster‖ que encabeza las operaciones y las distribuye a los ―nodos‖ con los cuales se comunica mediante una red de interconexión (ver figura 10). 27 Figura 10. Arquitectura de un cúster. Fuente: Clústers de alto rendimiento. Disponible en: http://goo.gl/j7tgJ1 Los clústeres tienen una clasificación: o Alto rendimiento: Estos clústers se utilizan para ejecutar programas paralelizables que requieren de gran capacidad computacional de forma intensiva. Son de especial interés para la comunidad científica o industrias que tengan que resolver complejos problemas o simulaciones. o Alta disponibilidad: Los clústers de alta disponibilidad tienen como propósito principal brindar la máxima disponibilidad de los servicios que ofrecen. Esto se consigue mediante software que monitoriza constantemente el clúster, detecta fallos y permite recuperarse frente a los mismos. o Balanceo de carga: Este tipo de clúster permite distribuir las peticiones de servicio entrantes hacia un conjunto de equipos que las procesa. Se utiliza principalmente para servicios de red sin estado, 28 como un servidor web o un servidor de correo electrónico, con altas cargas de trabajo y de tráfico de red. (Esteban, 2010) 2.3 Spark. Spark es un framework de computación paralela de código abierto, desarrollado en la universidad de U.C. Berkeley como un proyecto de fin de carrera. Como se mencionó anteriormente, los datos que en la actualidad se pretende analizar pueden ser muy grandes, más de lo que podría soportar una sola máquina, y es ahí donde Spark interviene almacenando y analizando los datos a través de múltiples máquinas que forman parte de un clúster. Spark se adapta muy bien al manejo de datos expresados en grafo ya que almacena los datos en la memoria (RAM) de cada nodo del clúster, a diferencia de Hadoop, que almacena los datos en disco. Mientras Hadoop puede manejar el acceso secuencial de datos, Spark puede manejar órdenes de acceso arbitrario requerido por un sistema de grafos, que tiene que recorrer el grafo a partir de un nodo específico. Además de que difieren con respecto a ―en dónde se procesan los datos durante el cálculo‖ (RAM vs disco), el API del Spark es mucho más fácil de trabajar que la API de Hadoop Map/Reduce. La gente empezó a usar Spark para los grafos hace mucho tiempo, incluso con el módulo Bagel (predecesor), pero ahora con GraphX tenemos una forma estandarizada para hacerlo, y por supuesto que proporciona una biblioteca de algoritmos útiles también. (Malak, 2015) 2.3.1 Resilient Distributed Dataset. El concepto central en Apache Spark es el conjunto de Datos Distribuido Resiliente (RDD). Es una colección distribuida inmutable de datos que se 29 reparte a través de las máquinas en un clúster. Facilita dos tipos de operaciones: la transformación y la acción. Una transformación es una operación como filter(), map(), o union() en un RDD que produce otro RDD. Una acción es una operación como count(), first(), taken(n), o colect() que desencadena un cálculo, devuelve un valor de nuevo al Maestro, o escribe a un sistema de almacenamiento estable. Las transformaciones son evaluadas lentamente, en el sentido de que no se ejecutan hasta que una acción lo justifique. El Master/Driver de Spark recuerda las transformaciones aplicadas a un RDD, así que si se pierde una partición (por ejemplo se da de baja a un nodo), la partición puede ser fácilmente reconstruida en alguna otra máquina en el clúster. Es por eso que se llama "resistente". (Kuntamukkala, s.f.) Spark está basado en Hadoop Map/Reduce y tiene en sí cuatro librerías: Spark SQL, Spark Streaming, MLlib, Graphx. Recientemente se ha agregado Spark R que es una integración de R con Spark. 2.3.2 Spark SQL. Spark SQL es un módulo de Spark para trabajar con datos estructurados, que proporciona una forma común para acceder a una variedad de fuentes de datos, incluyendo Avro, ORC, JSON, JDBC o Hive3. Se puede utilizar en Java, Scala, Python y R. (Apache Spark, 2015) Data Frames: Una trama de datos es una colección distribuida de datos organizados en columnas con nombre. Es conceptualmente equivalente a una tabla en una base de datos relacional o una trama de datos en R/Python, pero con optimizaciones más enriquecidas. Las tramas de datos se pueden construir a partir de una amplia gama de fuentes, tales como: 3 El software de almacenamiento de datos Apache Hive ™ facilita la consulta y gestión de grandes conjuntos de datos que residen en un almacenamiento distribuido. Hive ofrece un mecanismo para consultar los datos utilizando un lenguaje similar a SQL llamado HiveQL. 30 archivos estructurados de datos, bases de datos externas, o RDDs existentes. (Apache Spark, 2015) Data Source: Spark SQL admite operaciones en una variedad de fuentes de datos a través de la interfaz de trama de datos. Una trama de datos puede ser operado como RDD normal y también puede ser registrado como una tabla temporal. El registro de una trama de datos en forma de tabla le permite ejecutar consultas SQL sobre sus datos. 2.3.3 Spark Streaming. Spark Streaming es una extensión del núcleo del API de Spark que permite un flujo de procesamiento escalable, de alto rendimiento, con tolerancia a fallos y en tiempo real. Los datos pueden ser extraídos de muchas fuentes, como Kafka, Flume, Twitter, ZeroMQ, Kinesis, o sockets TCP, y pueden ser procesados usando algoritmos complejos expresadas con funciones de alto nivel como map, reduce y join. Por último, los datos procesados pueden ser insertados a los sistemas de archivos y bases de datos; de hecho, se puede aplicar algoritmos de aprendizaje automático y procesamiento de grafos de Spark en los flujos de datos. (Apache Spark, 2015) Figura 11. Funcionamiento de Spark Streaming. Fuente: Recuperado de: http://goo.gl/a5la0T. 2.3.4 Machine Learning Library (MLlib). 31 MLlib es la biblioteca de aprendizaje automático escalable de Spark que consiste en algoritmos y utilidades de aprendizaje en común, incluidas la clasificación, regresión, clústering, filtrado colaborativo, la reducción de dimensiones, así como primitivas de optimización subyacentes. MLlib está en constante desarrollo activo, por lo que la API puede cambiar en futuras versiones. 2.3.5 GraphX. Michael S. Malak, en su libro ―GraphX in Action‖ (Malak, 2015) afirma que: GraphX no es una base de datos, por lo que no puede actualizar ni eliminar datos de los nodos como sí lo podría hacer Neo4j o alguna de las bases de datos antes mencionadas, sino que es una librería de Spark para el procesamiento de grafos en paralelo, capaz de competir en rendimiento con los sistemas más rápidos, mientras que conserva la flexibilidad de Spark, la tolerancia a fallos, y la facilidad de uso. Graphx tiene varios algoritmos, como son: PageRank: PageRank mide la importancia de cada vértice en un grafo, en el supuesto de un borde de u a v representa la importancia de v para u. Por ejemplo, si un usuario de Twitter es seguido por muchos otros, el usuario será altamente calificado. Connected Components: Un componente conectado corresponde a un grafo o sub grafo en el que existe un camino entre cualquier par de nodos. Este algoritmo determina el grado de conectividad que tiene un grafo; sirve para detectar comunidades aisladas y el grado de cohesión de esas comunidades. Triangle Counting: Un vértice es parte de un triángulo cuando tiene dos vértices adyacentes con un borde entre ellos. GraphX implementa un algoritmo de conteo triángulo en el objeto TriangleCount que determina el número de 32 triángulos que pasan a través de cada vértice, proporcionando una medida de la agrupación. GraphX tiene también una cualidad que lo hace muy eficiente a la hora de repartir la carga de trabajo, y es la manera en que particiona el grafo: El enfoque tradicional de particionamiento que usan otros motores de procesamiento consiste en repartir los vértices entre los nodos del clúster, a este enfoque se le llama corte de borde (Edge-cut) como se ilustra en la figura 12, el problema de este tipo de particionamiento es que existen vértices de alto grado (high-degree vertex) que suelen generar cuellos de botella. Figura 12. Corte de borde. Fuente: Recuperado de: https://goo.gl/x1zmxK Un vértice de alto grado es un vértice que tiene muchas relaciones tanto de entrada como de salida, observe la figura 13. Figura 13. Vértice de alto grado. 33 Fuente: Michael S. Malak. Spark GraphX in Action. Un vértice de alto grado por ende toma más tiempo al computar, por lo que GraphX emplea un enfoque llamado corte de vértice (Vertex-cut), en el que los vértices son particionados y propagados a través de los nodos del clúster. Figura 14. Corte de vértice. Fuente: Recuperado de: https://goo.gl/x1zmxK La figura 15 muestra cómo quedaría la tabla de particionamiento de un grafo utilizando ambos enfoques. Figura 15. Tabla de un corte de vértice de GraphX. Fuente: Recuperado de: https://goo.gl/x1zmxK 2.4 Tecnologías asociadas 34 Para poder compilar Spark en cualquier computador, es necesario instalar algunas herramientas previamente. Tales herramientas se abordarán a lo largo de esta sección. 2.4.1 Scala. El nombre Scala significa "lenguaje escalable." El lenguaje se llama así porque fue diseñado para crecer con las demandas de sus usuarios. Puede aplicar Scala a una amplia gama de tareas de programación, desde escribir pequeños scripts para la construcción de grandes sistemas. Técnicamente, Scala es una mezcla de conceptos orientados a objetos y la programación funcional en un lenguaje de tipos estáticos. Sus construcciones orientadas a objetos hacen que sea fácil de estructurar sistemas más grandes y adaptarlos a las nuevas exigencias. La combinación de ambos estilos en Scala permite expresar nuevos tipos de patrones de programación y abstracciones de componentes. También conduce a un estilo de programación legible y conciso. (Martin Odersky, 2008) Scala es también el lenguaje de programación en el que fue construido Spark, por lo tanto se ha usado para la implementación de GraphX. 2.4.2 SBT (Simple Build Tools). SBT es una herramienta de código abierto para la construcción de proyectos en Scala y Java, algo similar a Maven (ver sección 2.4.4), y está escrito precisamente en Scala. Ha sido desarrollada por Mark Harrah y su primera versión estable se lanzó el 20 de marzo de 2015. SBT puede ser ejecutado tanto en MacOS como en Linux. Su instalación es un requisito indispensable para la compilación de Spark. 35 2.4.3 JDK (Java Development Kit). Java Platform, Standard Edition (Java SE) le permite desarrollar y desplegar aplicaciones Java en equipos de sobremesa y servidores, así como en los exigentes entornos integrados de hoy. Java ofrece la rica interfaz de usuario, rendimiento, versatilidad, portabilidad y seguridad que las aplicaciones de hoy en día requieren. La Plataforma Java, Standard Edition 8 (Java SE 8) es el último lanzamiento y el más importante. Contiene nuevas funciones y mejoras en muchas áreas funcionales. Java SE 8 ofrece una mayor productividad de los desarrolladores de aplicaciones y significativos aumentos de rendimiento mediante la reducción de código repetitivo, la mejora de las colecciones y las anotaciones, los modelos de programación paralela más simples y un uso más eficiente de los procesadores modernos, multi-core. (ORACLE, 2015) 2.4.4 Apache Maven. De acuerdo a la página oficial de Apache: Apache Maven es una herramienta de gestión de proyectos de software, basada en el concepto de un modelo de objetos del proyecto (POM); Maven puede gestionar la construcción de un proyecto, generación de informes y documentación de una pieza central de la información. (The Apache Software Foundation, 2015) 36 CAPÍTULO 3: INSTALACIÓN, CONFIGURACIÓN Y DESPLIEGUE DE SPARKGRAPHX 37 3.1 Instalación de Spark Para poder ejecutar Spark es necesario instalar varios componentes adicionales, la omisión de cualquiera de ellos puede impedir el levantamiento del framework. El trabajo detallado en este documento se realizó sobre Ubuntu 14 y Mac OS. La instalación en Linux y Mac varía en un mínimo porcentaje en la sintaxis de los comandos (en Mac se debe agregar ―./‖ antes de los comandos especificados), por lo demás los componentes requeridos para su correcta compilación son exactamente los mismos, los cuales se detallan a continuación: - SBT. - Scala. - JDK. - Maven. La instalación de cada uno de ellos se detallará en la sección de Anexos. Una vez instalado todo, es necesario descargar la última versión de Spark (estable) desde la página oficial para luego descomprimirlo. Una vez descomprimido se debe acceder a una terminal y navegar hasta el directorio donde se descomprimió Spark y escribir el siguiente comando: mvn -DskipTests clean package ó sbt/sbt-assembly Con este comando se compila Spark, este proceso toma alrededor de 30 a 40 minutos aproximadamente, luego de eso se procede a escribir el siguiente comando: bin/spark-shell 38 Con este comando se empezará a levantar el Shell de Spark para empezar a escribir código en Scala. Nota: Es posible escribir también aplicaciones en Java y Python ya que Spark tiene una integración con estos lenguajes de programación, aunque GraphX aún no está soportado en Python; y, algo a tener en cuenta, es que Spark fue escrito en Scala. Figura 16. Levantamiento del shell de Spark. Fuente: El Autor. Lo primero que se hizo fue una familiarización con el entorno de desarrollo y el lenguaje de programación, uno de los primeros ejercicios aplicados fue el de ―SparkPi‖ que viene incluido en el directorio de Spark4, este algoritmo se aplicó sobre una instalación de un clúster privado denominado ―Standalone‖ cuya implementación se describirá en la siguiente sección. 3.2 Spark Standalone Clúster Spark ofrece un modo simple para implementar un clúster privado, este modo se denomina Standalone. La arquitectura de Standalone se describe en la figura 17. 4 El archivo se encuentra en la ruta: ―spark-1.2.2\examples\src\main\scala\org\apache\spark\examples‖. 39 Figura 17. Arquitectura de Standalone Cluster. Fuente: Recuperado de: http://goo.gl/77Uw8y. Para construirlo se debe modificar ciertos archivos de configuración ubicados dentro del directorio de Spark, como se verá más adelante. Para que sea posible la comunicación entre el nodo máster y los nodos esclavos es necesario tener instalado ―OpenSSH Server‖ en el nodo Máster y que todos los nodos estén conectados a la misma red, en la misma VLAN. También es necesario que cada nodo del clúster cuente con una versión compilada de Spark (revisar la sección 3.1) y que los datasets a analizar estén replicados en cada uno de los nodos. Para configurar este tipo de clúster se debe seguir los siguientes pasos: 1. Acceder al directorio donde se descomprimió Spark e ingresar a la carpeta ―conf‖ en la que se modificarán tres archivos: a. El primer archivo a modificar es ―spark-env.sh.template‖ el cual se debe copiar y renombrar a ―spark-env.sh‖. Al final de este archivo se debe agregar las siguientes líneas: export SPARK_MASTER_IP='IP del Master' export SPARK_MASTER_PORT='Puerto por donde escucha el Master' export SPARK_MASTER_WEBUI_PORT='Puerto interfaz web' 40 Un ejemplo de cómo quedaría este archivo sería: export SPARK_MASTER_IP='172.16.88.107' export SPARK_MASTER_PORT='7077' export SPARK_MASTER_WEBUI_PORT='8080' b. El segundo archivo a modificar se llama ―slaves.template‖ que deberá quedar como ―slaves‖. En este archivo irán todas las direcciones IP de nuestros nodos esclavos, con los cuales el nodo máster se comunicará vía SSH. c. El tercer archivo a modificar se llama ―spark-defaults.conf.template‖ que debe quedar como ―spark-defaults.conf‖. Este archivo tiene varias líneas que están comentadas (con el signo # al inicio de cada línea), al final debe quedar de la siguiente manera: Figura 18. Archivo spark.desaults.conf. Fuente: El Autor. Como se observa en la Figura 18, las únicas líneas descomentadas son ―spark.master‖, que contiene la dirección IP y el puerto por donde escuchará el máster, y ―spark.executor.memory‖ (agregada posteriormente) que es la que le indica a Spark qué cantidad de memoria RAM se utilizará de cada nodo esclavo. 41 2. Una vez realizadas estas configuraciones, se procede a levantar el clúster mediante algunos scripts que se detallan a continuación: a. sbin/start-master.sh: Este comando sirve para levantar el Máster de nuestro clúster. b. sbin/start-slaves.sh: Con este comando se levantan todos los nodos esclavos cuyas direcciones IP se encuentren en el archivo ―slaves‖. c. sbin/start-all.sh: Con este comando se levanta todo, tanto el máster como los esclavos. Una vez iniciado el máster se creará una URL mediante la cual podremos conectar otros nodos al Máster (mediante otro método que se explica en el punto 3). Esta URL por defecto es http://localhost:8080 cuya interfaz se muestra en la figura 19. Figura 19. Web UI Spark Standalone. Fuente: El Autor. 3. Otra manera de agregar un nodo esclavo (worker) al clúster es: desde el mismo nodo acceder por consola a la carpeta de Spark y digitar el siguiente comando: 42 bin/spark-class org.apache.spark.deploy.worker.Worker spark://IP:PORT IP = la dirección IP del Máster; PORT = el puerto por donde escucha el Máster. En este caso el comando sería: bin/spark-class org.apache.spark.deploy.worker.Worker spark://172.16.88.107:7077 Cada vez que se agrega un nodo al clúster se debe actualizar la Web UI en el nodo máster para que aparezcan los nuevos nodos agregados (véase figura 17). Figura 20. Nuevo nodo agregado. Fuente: El Autor. 4. Ahora, el primer ejemplo para probar el clúster será el antes mencionado, SparkPi, que se lo podrá ejecutar mediante el siguiente comando: bin/spark-submit \ --class org.apache.spark.examples.SparkPi \ --deploy-mode client \ --master spark://172.168.88.107:7077 \ /home/daniel/Descargas/spark-1.2.2/examples/target/scala2.10/spark-examples-1.2.0-hadoop1.0.4.jar 10 43 Nota: Reemplazar con sus datos la dirección del máster, el puerto y el directorio en donde tiene su archivo .jar compilado. Hasta ahora se ha visto cómo levantar Spark y cómo ejecutar instrucciones en paralelo, sobre un clúster (Standalone). En la siguiente sección se entrará más en materia, ya no ejecutando algoritmos pre-compilados solamente, sino que se empezará a hondar en el tema central de este trabajo, la implementación de GraphX, las métricas que se pueden aplicar sobre un grafo y los tiempos de respuesta. 3.3 Hadoop YARN. Hadoop YARN es el cluster manager de Hadoop5, que brinda mayor seguridad y una mejor administración de recursos con respecto a Standalone. Spark se puede ejecutar sobre un clúster YARN, por lo tanto Spark se desliga de cualquier responsabilidad con respecto a la administración del clúster y su labor se limita exclusivamente a la ejecución de los algoritmos que provee, mientras que la administración del clúster y de los recursos la lleva por completo YARN. Hadoop YARN da solución al inconveniente que se tenía con Standalone, en el que había que replicar los datasets en todos los nodos para poder procesar la data; YARN cuenta con un Resource Manager que es el que se encarga de distribuir los recursos a todos los nodos del clúster. La arquitectura de YARN consta de un Resource Manager, Node Manager, Application Master and Container, como se muestra en la figura 21. 5 Vea más detalles en: https://hadoop.apache.org/docs/current/hadoop-yarn/hadoop-yarn-site/YARN.html. 44 Figura 21. Arquitectura de YARN. Fuente: Recuperado de: http://goo.gl/77Uw8y. Hadoop permite realizar una instalación y configuración de clústers de dos tipos: Single Node (con un solo nodo) y Multi Node (con más de un nodo). Además, Spark se puede ejecutar sobre YARN de dos maneras: yarn-client mode y yarn-cluster mode. La tabla 1 muestra comparativa de cómo trabaja Spark sobre YARN en ambos modos y sobre Standalone. Tabla 1. Comparativa entre Spark sobre YARN y Standalone Cluster. Mode YARN Client Mode YARN Cluster Mode Spark Standalone Driver runs in Client ApplicationMaster Client Requests resources ApplicationMaster ApplicationMaster Client Starts executor processes YARN NodeManager YARN NodeManager Spark Worker Persistent services YARN ResourceManager and NodeManagers YARN ResourceManager and NodeManagers Spark Master and Workers Supports Spark Shell Yes No Yes Nota: Como se puede observar en la tabla 1, solo el modo Yarn-Client soporta el Shell de Spark. En lo que respecta al presente trabajo, la instalación de YARN se realizó sobre Mac OS, y se realizó una configuración Single-Node. Para conocer detalles de su 45 instalación revisar el Anexo H, ya que en esta sección solo se abordará aspectos generales sobre el tema. Antes de descargar e instalar Hadoop es necesario tener instalado ciertos componentes: - Java. - SSH server. Además se debe tener establecidas las variables de entorno para Java. Luego es necesario descargar Hadoop desde su sitio oficial. Para este trabajo se utilizó Hadoop 2.6. Una vez descargado, descomprimirlo en el lugar de su preferencia (recordar la ruta en donde se descomprimió). Para configurar el clúster YARN (single-node) es necesario acceder vía terminal al directorio en donde se descomprimió Hadoop, luego ir a la carpeta ―etc/hadoop‖. Dentro de ella se encuentran varios archivos, de los cuales se debe modificar: hadoop-env.sh. mapred-env.sh. yarn-env.sh. core-site.xml. hdfs-site.xml. mapred-site.xml. yarn-site.xml. El detalle de esas configuraciones se detallará en el Anexo H. Una vez configurados esos archivos, es necesario crear los directorios en donde se almacenarán la información del datanode y namenode. De la siguiente manera: $ mkdir -p /home/users/aqua/hadoop/namenode $ mkdir -p /home/users/aqua/hadoop/datanode Finalmente se procede a dar formato al HDFS6 para el almacenamiento de datos (datanode) y metadatos (namenode). Para ello se debe acceder vía terminal al directorio donde se encuentra Hadoop, y escribir el comando: $ hdfs namenode -format 6 Hadoop Distributed File System, para más información visite: https://goo.gl/OFaPKv. 46 Una vez terminado ese proceso se puede empezar a levantar el clúster YARN utilizando los siguientes comandos: $ ./start-dfs.sh $ ./start-yarn.sh Para verificar que Hadoop está corriendo es necesario ejecutar el comando ―jps‖ (java process monitor), cuyo resultado debe mostrar lo siguiente: $ jps 7379 7459 7316 7636 7562 7676 DataNode SecondaryNameNode NameNode NodeManager ResourceManager Jps Debe cerciorarse de que todos estos procesos estén corriendo, caso contrario el clúster YARN no funcionará correctamente. Hadoop ofrece algunas herramientas basadas en la web para monitorear HDFS, MapReduce, y tareas en un modo Single-Node: HDFS Administrator: http://localhost:50070. Figura 22. Administración Web del HDFS. Fuente: Recuperado de: http://goo.gl/VhCVCY. 47 ResourceManager Administrator: http://localhost:8088. Figura 23. Administrador Web del Resource Manager. Fuente: Recuperado de: http://goo.gl/XkGwsr. 3.3.1 Spark sobre YARN. Una vez configurado y levantado el clúster YARN, es posible ejecutar Spark sobre él. En el presente trabajo como se indicó anteriormente, se configuró un clúster singlenode. Lo primero que hay que hacer es descargar una versión de Spark pre-compilada para la versión de Hadoop que se haya instalado (Hadoop 2.6 en este caso). Figura 24. Descarga de Spark pre-compilado para Hadoop. Fuente: Recuperado de: http://spark.apache.org/downloads.html. Luego descomprimir en el directorio de su preferencia. 48 Acceder vía terminal hasta la carpeta donde se descomprimió Spark y ejecutar el comando: $ ./bin/spark-shell --master yarn-client Hecho esto se levantará el Shell de Spark sobre el clúster en YARN. Es importante recordar que el Spark-Shell solo está disponible en el modo Yarn-Client. 3.4 Análisis de grafos con GraphX En esta sección se describe el logro de uno de los objetivos principales de este trabajo de fin de titulación, que es determinar qué es lo que se puede hacer en GraphX, qué métricas del SNA están implementadas en esta librería y observar cómo se comporta al trabajar en plataformas como Linux y MAC, con ciertas variaciones en hardware también. En la sección 3.2 se revisó la configuración de un clúster privado (Standalone), ahora sobre ese clúster se efectuará un análisis de datos almacenados en grafo utilizando algunos datasets de diferentes características para la experimentación. En el SNA (Social Network Analysis) existen varias métricas que se aplican a un grafo, estas métricas se abordarán en detalle en el capítulo 4. GraphX tiene implementadas algunas de esas métricas, por ejemplo, el PageRank corresponde a una métrica de centralidad del SNA, en este caso de aplicación se ejecutó este algoritmo sobre una data que fue procesada en paralelo. En el Anexo G se detalla un caso práctico que sirve de ilustración para conocer cómo se puede desplegar GraphX. Para poner en marcha GraphX es necesario tener una versión compilada de Spark en cualquiera de sus versiones, y tener implementado un cluster manager, ya sea con Spark Standalone, Yarn o Mesos. 49 En cuanto a los datasets, no son otra cosa que archivos de texto plano que contienen la información a procesar; uno de ellos contiene la información de todos los nodos, el otro contiene exclusivamente las relaciones –desde, hacia–. Lo que hace el código descrito en el Anexo E, es un join entre la información de ambos archivos para poder construir el grafo en Spark-Graphx y realizar el procesamiento sobre el mismo. 50 CAPÍTULO 4: MÉTRICAS DEL SNA – GRAPHX 51 4.1 Métricas del SNA Uno de los propósitos del SNA es determinar la importancia de los actores, el nivel de participación de cada uno de ellos dentro del grafo, quiénes son los que manejan el mayor flujo de información, etc. A más de eso, determinar también el grado de cohesión y agrupamiento en el grafo. Para ello existen algunas métricas que se estudiarán en las siguientes secciones. 4.1.1 Centralidad de Grado (Degree Centrality). El grado de centralidad corresponde al número de relaciones directas que tiene un individuo, en un grafo dirigido se puede decir que son las relaciones tanto de entrada como de salida; entre más relaciones directas tenga un nodo, será un nodo de más alto grado. El grado de entrada (indegree) corresponde a las relaciones que vienen desde otros nodos, es decir, el número de actores que se relacionan con X actor. El grado de salida (outdegree) por su parte corresponde a las relaciones que van desde un nodo determinado hacia otros actores. 4.1.2 Centralidad de Intermediación (Betweenness Centrality). ―La centralidad vista como mediación se define como el nivel en que otros actores deben pasar a través de un actor focal para comunicarse con el resto de los actores.‖ (Menéndez, 2003) Los actores con un alto grado de intermediación son generalmente los que manejan el mayor flujo de información y aparecen muy a menudo cuando se busca caminos geodésicos7 entre pares de nodos. 7 Se denomina camino geodésico al camino de menor longitud (de entre todos los posibles), que une cualquier par de nodos. 52 4.1.3 Centralidad de Cercanía (Closeness Centrality). La centralidad de cercanía se define como la capacidad que tiene un actor para llegar a los actores de toda la red, mediante el menor número de conexiones. Un individuo con una alta puntuación de cercanía es más probable que sea un tomador de decisiones, o un líder operativo de la red, ya que son la pieza cohesiva que mantiene la red unida. (SS8, s.f.) 4.1.4 Centralidad Vector Propio. Denota el grado en que un actor es un pez grande conectado con otro gran pez en un estanque muy grande. La centralidad de vector propio se calcula evaluando qué tan bien conectado está un actor a las partes de la red con la mayor conectividad. Los actores con puntuaciones altas de este tipo tienen muchas conexiones y sus conexiones tienen muchas otras conexiones, y sus otras conexiones tienen muchas otras conexiones, etc., así hasta el final de la red. 4.1.5 Coeficiente de agrupamiento. Esta medida evalúa la posibilidad de que dos nodos adyacentes a un nodo específico sean vecinos entre sí. 4.1.6 Densidad. La densidad de una red es la relación existente entre el número de lazos existentes y el número de lazos posibles. En las redes desigualmente conectadas, la densidad hace posible medir las áreas más o menos ligadas o enlazadas de la red, y detectar el vecindario de un nodo dado, como los grupos y ―cliques‖, los cuales son reconocidos por su cohesión de acuerdo con la proporción de relaciones entre los nodos. (Polanco, 2008) 53 4.2 SNA – GraphX. GraphX ofrece la posibilidad de aplicar muchas de estas métricas en el análisis de grafos. La tabla 2 muestra un resumen de algunas de las métricas que están implementadas en GraphX. Tabla 2. Métricas implementadas en Graphx. Fuente: El Autor. Métrica Implementada en Graphx Autovector (Eigen Vector) Sí Cercanía (Closeness) Sí Intermediación (Betweenness) Sí Densidad (Density) Sí Puente (Bridge) No Coeficiente de agrupamiento (Clustering) Sí Cohesión (Cohesion) Sí Homofilia (Homophily) No Multiplicidad (Multiplicity) No Reciprocidad (Reciprosity) No Distancia (Distance) No Transitividad (Transitivity) Sí Modularidad (Modularity) Sí Eficiencia (Efficiency) No Diámetro (Diameter) No Equivalencia estructural No PageRank es un algoritmo conocido que determina la importancia de un vértice en un grafo. Fue ofrecido por Google en 1998 y se ha utilizado para clasificar los resultados de búsqueda. 54 La búsqueda de componentes conectados es el algoritmo para buscar subconjuntos de actores en un grafo. Hay un camino entre dos vértices de un subconjunto específico. Al mismo tiempo, no hay camino entre los vértices de los diferentes subconjuntos. Además de lo anterior, GraphX ofrece conteo de triángulos, clustering, búsqueda de cliques, etc. La mayoría de los algoritmos son iterativos, por lo tanto, GraphX se desempeña bien en este contexto, ya que almacena los datos en memoria. (Krot, 2015) 4.2.1 Casos de aplicación. Predicción de enlace En un grafo, a medida que pasa el tiempo van apareciendo cada vez nuevas relaciones, por ende es necesario poder de alguna manera predecir qué relaciones aparecerán en el futuro; precisamente se trata de sistemas recomendadores, que para cada par de actores (aleatorios) asumen la probabilidad de que aparezca una relación que los una. Detección de Comunidades Mauricio Monsalve menciona al respecto que: La detección de comunidades, grupos, cliques (grupos exclusivos), etc. es tema de alto interés en redes sociales. El asunto es complicado pues no es fácil definir un grupo. La definición es fácil cuando hablamos de una estructura formal, cuando existe un grupo definido y un grupo de adherentes que dice ser parte del grupo. Por ejemplo, Chile y los chilenos. Pero todo se vuelve complicado, oscuro, hasta esotérico cuando hablamos de la estructura informal. Un grupo de amigos es un montón de gente que son todos o casi todos amigos 55 entre sí, pero ellos a su vez tienen varios amigos comunes... ¿Cuáles pertenecen al grupo y cuáles no? (Moreno, 2008) La determinación de líderes de opinión en la Red Por ejemplo, suponga que necesitamos promover un nuevo servicio o producto; para optimizar el presupuesto de publicidad nos gustaría seleccionar a las personas que están, en algún sentido, en el centro de atención, para que sean ellos quienes difundan toda la información referente al nuevo producto o servicio que se quiere prestar, ya que a través de ellos se puede llegar a muchas más personas sin tener que pagar por una publicidad radio-televisiva. En nuestros términos, esas personas vienen a ser vértices de un grafo, que tienen una gran importancia en la red. Con la estructura correcta del grafo, este problema se reduce al PageRank. (Krot, 2015) 56 CONCLUSIONES Una vez finalizado el proyecto, habiendo conseguido una instalación y ejecución exitosa de Spark-GraphX, se puede llegar a las siguientes conclusiones: Se logró realizar una instalación limpia de Spark y la aplicación de su algoritmo para el procesamiento de grafos en paralelo GraphX, tanto en Linux (Ubuntu 14) como en Mac OS. La instalación en Mac no difiere mucho con respecto a la instalación en Ubuntu, excepto en la sintaxis de los comandos. También se pudo constatar que para ambas plataformas se requiere exactamente de los mismos componentes, para poder instalar Spark (ver sección 2.4). Se hizo varias iteraciones, en cada una de ellas se fue variando el hardware asignado para el clúster y los datos a analizar. Uno de los aspectos que también se consideró (aunque no era el foco central del proyecto) fue la velocidad de procesamiento de Graphx; evidentemente, a mayor disponibilidad de hardware, mayor velocidad de procesamiento (ver Anexo G, Tabla 3); este aspecto también depende de factores como: o Cantidad de nodos disponibles para el clúster. o Número de cores y memoria RAM disponibles (por nodo). o Tamaño de la información a analizar. o Algoritmo a ejecutar. Con base en la experiencia obtenida, se deduce que no existen requerimientos de hardware ―específicos‖ para implementar Spark, todo depende de la magnitud de lo que se quiera hacer, específicamente de la cantidad de información que se desee procesar. No es necesario que todos los nodos del clúster tengan las mismas características de hardware, al final GraphX es quien se encarga de hacer la distribución equitativa de la carga de trabajo. 57 Se llegó a implementar dos tipos de Cluster-Manager: Standalone (integrado en Spark) y YARN (Single-Node). GraphX solo fue ejecutado sobre Standalone Cluster, no se llegó a ejecutar sobre YARN. Con respecto a YARN, solo se llegó a su instalación y conexión con Spark en Mac OS, es decir que, se logró levantar el Shell de Spark sobre un clúster (YARN) en funcionamiento. Queda pendiente implementar YARN Multi-Node, para determinar cómo se comporta a la hora de administrar los recursos para la ejecución de los algoritmos de GraphX y ver qué tanto podría ayudar a mejorar su desempeño. Se llegó a construir un grafo en GraphX mediante la importación de dos tipos de datasets: el primero contenía la información de los nodos, el segundo contenía información de las relaciones (ID origen – ID destino) entre los nodos. Luego se ejecutaron los algoritmos de GraphX sobre el grafo. Uno de los datasets que se analizó contenía información referente a universidades, que hacían referencia a otras universidades. Se ejecutó un PageRank sobre aquellos datos, de ese resultado se extrajo las 10 universidades con más alto grado de importancia (Ranks) de entre todas, basado en las referencias de otras universidades hacia ellas. También se aplicaron algoritmos como Triangle Counting y Connected Components; dichos algoritmos corresponden a métricas de centralidad y clustering, que es el fuerte de GraphX. La interpretación de los resultados obtenidos de este análisis, queda a criterio del investigador que desee poner en marcha esta tecnología a partir de este trabajo de fin de titulación, y quiera llegar más allá de su sola implementación. 58 RECOMENDACIONES Luego de haber finalizado el proyecto y de haber llegado a varias conclusiones, se pone a consideración del lector algunas recomendaciones para futuros trabajos que pretendan surgir a partir de éste: Spark puede ser probado en una sola máquina, incluso se puede montar un clúster usando máquinas virtuales, pero no es muy recomendable ya que Spark está diseñado para trabajos a gran escala y para la utilización de gran cantidad de hardware, por lo que si se lo implementa en una sola máquina ésta puede verse afectada en su rendimiento. Es importante tener en cuenta el hecho de que todos los nodos del clúster deben estar conectados a la misma red, en la misma VLAN, si no se toma en cuenta esto habrá problemas de comunicación al intentar agregar un nodo esclavo al clúster. Lo ideal para trabajar con Spark es contar con un ―Resource Manager‖ al cual apunten todos los nodos y de donde puedan consumir los recursos necesarios. Esto se puede conseguir mediante la implementación de Cluster-Managers como Mesos y YARN (que sí se llegó a implementar), de esta manera se evitará la incómoda replicación de los datasets en cada uno de los nodos del clúster y se tendrá mayor seguridad. Para la construcción de un Grafo en Graphx se requirió como datos de entrada archivos de texto plano (.txt), que contenían la información de los nodos y sus relaciones, pero no se probó con archivos XML o CSV; sería interesante determinar si es posible importar datos en esos formatos de archivos. Presentar los resultados de GraphX gráficamente (con la ayuda de algún software, como por ejemplo: Gephi) y tener la información un poco más legible (como para usuarios no avanzados), ya que todos los resultados de los 59 algoritmos aplicados se mostraban con mensajes del servidor incluidos, y en consola. La manera en que se implementó Graphx en este trabajo de fin de titulación no es la única existente, y no necesariamente la mejor; lo interesante sería poder aplicar un procesamiento de este tipo, conectando Spark-Graphx a una base de datos en producción (como Neo4j por ejemplo) y aplicar minería de datos directamente sobre la base de datos y no sobre datasets exportados. 60 BIBLIOGRAFÍA Aguirre, J. L. (Diciembre de 2011). Introducción al Análisis de Redes Sociales. Obtenido de http://www.pensamientocomplejo.com.ar/docs/files/J.%20Aguirre.%20Introducci%F3 n%20al%20An%E1lisis%20de%20Redes%20Sociales.pdf Apache Spark. (2015). Spark SQL and DataFrame Guide. Obtenido de http://spark.apache.org/docs/latest/sql-programming-guide.html#dataframes Apache Spark. (2015). Spark Streaming Programming Guide. Obtenido de http://spark.apache.org/docs/latest/streaming-programming-guide.html Chen, R. (junio de 2015). Obtenido de https://github.com/realstolz/powerlyra Dato-Code. (s.f.). PowerGraph. Obtenido de https://github.com/dato-code/PowerGraph Esteban, P. C. (02 de 08 de 2010). Introducción a los Clusters. Obtenido de http://www.lintips.com/?q=node/117 Grupo TRC. (s.f.). Conceptos Básicos de Big Data. Obtenido de http://www.trc.es/pdf/descargas/big_data.pdf Ian Robinson, J. W. (2015). Graph Databases. Beijing: O’Reilly Media, Inc., 1005 Gravenstein Highway North. IBM. (18 de Junio de 2012). ¿Qué es Big Data? Obtenido de https://www.ibm.com/developerworks/ssa/local/im/que-es-big-data/ IDATHA. (Diciembre de 2014). BIG DATA – Conceptos Generales: White Paper - IDATHA. Obtenido de http://www.idatha.com/es/whitepapers/Whitepaper-BigData.pdf INSNA. (s.f.). What is Social Network Analysis? Obtenido de http://www.insna.org/what_is_sna.html Ipiña, D. L. (8 de Noviembre de 2012). Bases de Datos No Relacionales (NoSQL). Obtenido de http://es.slideshare.net/dipina/bases-de-datos-no-relacionales-nosql J. Aguilar, E. L. (2004). Introducción a la Computación Paralela. Merida. Krot, A. (25 de Marzo de 2015). Social Network Analysis. Spark GraphX. Obtenido de http://kukuruku.co/hub/algorithms/social-network-analysis-spark-graphx Kuntamukkala, A. (s.f.). Apache Spark, An Engine for Large-Scale Data Processing. Obtenido de https://dzone.com/refcardz/apache-spark Lantares. (s.f.). Velocidad, variedad y volumen, las 3 magnitudes clave de Big Data. Obtenido de http://www.lantares.com/blog/velocidad-variedad-y-volumen-las-3-magnitudesclave-de-big-data Malak, M. S. (2015). En M. S. Malak, Spark GarphX in Action (pág. 25). Manning Publications. Maribel Tirados. (1 de Octubre de 2014). Bases de datos orientadas a grafos. Obtenido de Big Data Hispano: http://www.bigdatahispano.org/noticias/bases-de-datos-orientadas-agrafos/ 61 Martin Odersky, L. S. (10 de 12 de 2008). Programming in Scala, First Edition. Obtenido de http://www.artima.com/pins1ed/a-scalable-language.html Menéndez, L. S. (Julio de 2003). Análisis de redes sociales: o cómo representar las estructuras sociales subyacentes. Obtenido de http://digital.csic.es/bitstream/10261/1569/1/dt0307.pdf Moreno, M. M. (11 de Diciembre de 2008). Análisis de redes sociales: un tutorial. Obtenido de http://homepage.cs.uiowa.edu/~mmonsalv/bio/SNA.pdf Nasca, A. A. (12 de Agosto de 2014). Introducción a NoSQL - Graph DataBase Neo4j. Obtenido de https://prezi.com/xaitejgkpqsv/introduccion-a-nosql-graph-database-neo4j/ ORACLE. (2015). Obtenido de http://www.oracle.com/technetwork/java/javase/overview/index.html Polanco, X. (27 de Junio de 2008). An´alisis de redes: introducci´on. Obtenido de https://halpasteur.archivesouvertes.fr/file/index/docid/218397/filename/XP_Analisis_de_redes_2006.pdf Research, F. (22 de 12 de 2011). Relationship graph analysis is almost inherently "Big Data". Obtenido de http://blogs.forrester.com/james_kobielus/11-12-19the_year_ahead_in_big_data_big_cool_new_stuff_looms_large#comment-15468 SS8. (s.f.). Social Network Analysis. Obtenido de https://wikileaks.org/spyfiles/files/0/207_SS8SOCIALNETANALYS-201110.pdf Stanley Wasserman, K. F. (2013). Análisis de redes sociales, métodos y aplicaciones. Madrid. The Apache Software Foundation. (25 de 10 de 2014). Welcome to Apache Giraph! Obtenido de http://giraph.apache.org The Apache Software Foundation. (25 de 10 de 2014). Welcome to Apache Giraph! Obtenido de http://giraph.apache.org The Apache Software Foundation. (18 de 07 de 2015). Obtenido de Welcome to Apache Maven: https://maven.apache.org 62 ANEXOS 63 ANEXO A: INSTALACIÓN DE SBT. Para la instalación de SBT (Simple Build Tools) se debe seguir los siguientes pasos: a. Descargar SBT, lo puede hacer desde su sitio web oficial. b. Mover el archivo .jar a la carpeta ―bin‖. c. Seguidamente, ir a la carpeta ―bin‖ y crear un archivo de texto con el siguiente script: SBT_OPTS="-Xms512M -Xmx1536M -Xss1M XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256M" d. Hacer el script ejecutable mediante el siguiente comando: chmod u+x /bin/sbt Otra manera de instalar SBT es ejecutandoo la siguiente cadena de comandos: echo "deb http://dl.bintray.com/sbt/debian /" | sudo tee -a /etc/apt/sources.list.d/sbt.list sudo apt-get update sudo apt-get install sbt En caso de tener algún error ejecute el comando: sudo apt-get -f install 64 ANEXO B: INSTALACIÓN DE SCALA. Para instalar SCALA debe ejecutar la siguiente cadena de comandos en una terminal: wget http://www.scala-lang.org/files/archive/scala-2.11.4.deb sudo dpkg -i scala-2.11.4.deb sudo apt-get update sudo apt-get install scala En caso de tener algún error ejecute el comando: sudo apt-get -f install 65 ANEXO C: INSTALACIÓN DE MAVEN. Para instalar Maven primeramente debe descargarlo desde su sitio web oficial, luego acceder al directorio de descarga, descomprimir y proceder a establecer las variables de entorno para el correcto funcionamiento de Maven. Desde una terminal acceder al directorio donde descomprimió Maven y ejecutar las siguientes líneas de comando: Figura 25. Variables de entorno para Maven. Fuente: El Autor. 66 ANEXO D: INSTALACIÓN DE JDK. La instalación de JDK se detalla en los siguientes pasos: a. Descargar Oracle Java JDK para Linux. Asegúrese de seleccionar los binarios “correctos” para la arquitectura de su sistema, 32-bit o 64-bit. Información importante: Los binarios de 64-bit Oracle Java no funcionan en Ubuntu Linux 32-bit, sólo aparecerán muchos errores. b. Copie los binarios en el directorio de /usr/local/java. En la mayoría de los casos, los binarios de Oracle Java se descargan en: /home/"nombre_de_usuario"/Downloads. 32-bit Oracle Java en 32-bit Ubuntu Linux, instrucciones de instalación: cd /home/"nombre_de_usuario"/Downloads sudo mv jdk-8u25-linux-i586.tar.gz /usr/local/java/ cd /usr/local/java 64-bit Oracle Java en 64-bit Ubuntu Linux, instrucciones de instalación: cd /home/"nombre_de_usuario"/Downloads sudo mv jdk-8u25-linux-x64.tar.gz /usr/local/java/ cd /usr/local/java Nota: Si salta un error de que no existe el directorio ―/usr/local/java/‖ se debe crear la carpeta java dentro del directorio ―/usr/local/‖. c. Ejecute los siguientes comandos en los archivos tar.gz descargados. Asegúrese de hacerlo como root para poder hacer que se ejecuten para todos 67 los usuarios en su sistema. Para abrir la terminal de root teclee ―sudo su‖, tendrá que proporcionar la contraseña de inicio de sesión. 32-bit Oracle Java en 32-bit Ubuntu Linux, instrucciones de instalación: sudo chmod a+x jdk-8u25-linux-i586.tar.gz 64-bit Oracle Java en 64-bit Ubuntu Linux, instrucciones de instalación: sudo chmod a+x jdk-8u25-linux-x64.tar.gz d. Descomprimir los binarios Java, en el directorio /usr/local/java 32-bit Oracle Java en 32-bit Ubuntu Linux, instrucciones de instalación: sudo tar xvzf jdk-8u25-linux-i586.tar.gz 64-bit Oracle Java en 64-bit Ubuntu Linux, instrucciones de instalación: sudo tar xvzf jdk-8u25-linux-x64.tar.gz e. Revise sus directorios. Hasta ahora deberá tener dos directorios binarios en /usr/local/java para el Java JDK/JRE: ls -a jdk1.8.0_25 f. Editar el archivo PATH del sistema /etc/profile y agregar las siguientes variables de sistema al PATH. Usar nano, gedit o cualquier otro editor de texto, como root, para abrir /etc/profile. sudo gedit /etc/profile O sudo nano /etc/profile 68 g. Desplácese hacia abajo hasta el final del archivo usando las teclas de flechas y agregue las siguientes líneas al final de su archivo /etc/profile. JAVA_HOME=/usr/local/java/jdk1.8.0_25 PATH=$PATH:$HOME/bin:$JAVA_HOME/bin export JAVA_HOME export PATH h. Guarde el archivo /etc/profile file y salga. i. Informe a su sistema de Ubuntu Linux dónde está ubicado el Oracle Java JDK/JRE. Esto le dirá a tu sistema que hay una nueva versión de Oracle Java. sudo update-alternatives --install "/usr/bin/java" "java" "/usr/local/java/jdk1.8.0_25/bin/java" 1 Este comando notifica al sistema que Oracle Java JRE está listo para usarse. sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/local/java/jdk1.8.0_25/bin/javac" 1 Este comando notifica al sistema que Oracle Java JDK está listo para usarse. sudo update-alternatives --install "/usr/bin/javaws" "javaws" "/usr/local/java/jdk1.8.0_25/bin/javaws" 1 Este comando notifica al sistema que Oracle Java Web Start está listo para usarse. j. Informe a su sistema que Oracle Java JDK/JRE debe ser el Java por defecto. sudo update-alternatives --set java /usr/local/java/jdk1.8.0_25/bin/java Este comando configurará el JRE para el sistema. 69 sudo update-alternatives --set javac /usr/local/java/jdk1.8.0_25/bin/javac Este comando configurará el Javac Compiler para el sistema. sudo update-alternatives --set javaws /usr/local/java/jdk1.8.0_25/bin/javaws Este comando configurará el Java Web Start para el sistema. k. Una instalación exitosa de 32-bit Oracle Java mostrará: java -version Este comando muestra la versión de Java que está en su sistema. Deberá recibir el siguiente mensaje: java version "1.8.0_25" Java(TM) SE Runtime Environment (build 1.8.0_25-b17) Java HotSpot(TM) Client VM (build 25.25-b02, mixed mode) javac -version Este comando deja saber que ya podrá compilar programas Java para la terminal. Deberá recibir un mensaje que diga: javac 1.8.0_25 l. Una instalación exitosa de Oracle Java 64-bit mostrará lo siguiente: java -version Este comando mostrará la versión de Java que está en su sistema. Deberá recibir un mensaje que diga: java version "1.8.0_25" Java(TM) SE Runtime Environment (build 1.8.0_25-b17) Java HotSpot(TM) 64-Bit Server VM (build 25.25-b02, mixed mode) 70 javac -version Este comando hace saber que ahora podrás compilar programas Java desde la terminal. Deberá recibir un mensaje que diga: javac 1.8.0_25 m. Ahora reinicie el sistema. Después de eso, su sistema estará completamente configurado para correr y desarrollar programas Java. 71 ANEXO E: APLICACIÓN DE EJEMPLO – GRAPHX. Este algoritmo es una aplicación en la que se implementa un PageRank sobre determinados datasets. Es posible reutilizarla con sus propios datos, siguiendo el proceso descrito en la sección 3.3. import org.apache.spark._ import org.apache.spark.graphx._ import org.apache.spark.rdd.RDD val graph = GraphLoader.edgeListFile(sc, "graphx/data/twrel.txt") // Run PageRank val ranks = graph.pageRank(0.0001).vertices val users = sc.textFile("graphx/data/twett.txt").map { line => val fields = line.split(",") (fields(0).toLong, fields(1)) } val ranksByUsername = users.join(ranks).map { case (id, (username, rank)) => (username, rank) } // Print the result println(ranksByUsername.collect().mkString("\n")) 72 ANEXO F: CAPTURAS GRAPHX Ilustración 1. Primera aplicación en el clúster. Fuente: El Autor Ilustración 2. Datos de aplicación finalizada. Fuente: El Autor. 73 Ilustración 3. Levantamiento del máster y localhost como nodo. Fuente: El Autor. Ilustración 4. Nodo externo agregado correctamente. Fuente: El Autor. 74 ANEXO G: DESPLIEGUE DE GRAPHX SOBRE STANDALONE-CLUSTER Para realizar este ejercicio se debe hacer lo siguiente: 1. Lo primero que hay que hacer es levantar el clúster Standalone, como se vio en la sección 3.2. 2. Los datasets utilizados corresponden a 2 archivos de texto (extensión .txt): a. El primero contiene la información de los nodos, los campos están separados ya sea por un espacio tabular o por una coma. En este caso el grafo corresponde a usuarios de Twitter y su estructura se muestra en la figura 26. Figura 26. Dataset – Nodos. Fuente: El Autor. b. El segundo contiene las relaciones, id de origen - id de destino, separados por un espacio tabular. 75 Figura 27. Dataset – Relaciones. Fuente: El Autor. 3. Replicar los datasets en todos los nodos que vayan a participar del clúster, el directorio especificado en este ejemplo es ―graphx/data‖. 4. En el nodo máster se debe ingresar a una terminal, navegar hasta el directorio de Spark y levantar del Shell de Scala pero sobre el clúster, observe la figura 28. Figura 28. Spark Shell sobre Standalone Cluster. Fuente: El Autor. El levantar el Shell de Scala sobre el clúster significa que todo el código que se escriba ahí será ejecutado en paralelo. 5. Lo que sigue es escribir la aplicación en el Shell de Scala: a. Lo primero que se debe hacer es importar las librerías correspondientes: 76 import org.apache.spark._ import org.apache.spark.graphx._ import org.apache.spark.rdd.RDD b. Luego hay que empezar a construir el grafo en GraphX, se empezará importando el archivo de las relaciones, almacenando el resultado en una variable, en este caso la variagle ―graph‖. val graph = GraphLoader.edgeListFile(sc, "graphx/data/twrel.txt") c. Luego se procede a ejecutar un PageRank sobre la variable que almacena las relaciones, con la siguiente línea de código: val ranks = graph.pageRank(0.0001).vertices d. Luego es necesario importar la información de los nodos y a almacenarla en una variable. val users = sc.textFile("graphx/data/twett.txt").map { line => val fields = line.split(",") (fields(0).toLong, fields(1)) } Nótese que al final de la tercera línea el valor declarado es ―,‖ ya que los atributos de los nodos están separados por una coma (véase figura 18); en caso de que los atributos estuvieran separados por un espacio tabular, en vez de la coma iría ―\t‖. e. Una vez cargada la información de los nodos es necesario hacer un join, relacionar cada usuario con su id, pero este join no será netamente sobre la variable que contiene las relaciones sino sobre la que contiene los Ranks. val ranksByUsername = users.join(ranks).map { case (id, (username, rank)) => (username, rank) } 77 f. Al final se imprime los resultados mediante la siguiente línea de código: println(ranksByUsername.collect().mkString("\n")) El resultado se muestra en la figura 29. Figura 29. Resultado PageRank. Fuente: El Autor. Finalmente se puede explorar un poco más el resultado. Si se desea tomar los primeros 10 elementos resultantes del PageRank, se puede utilizar el comando: ranksByUsername.take(10) Cuyo resultado se puede ver en la figura 30. Figura 30. Primeros 10 elementos del resultado. Fuente: El Autor 78 Si se desea tomar los 10 primeros elementos, pero por prioridad, entonces se puede ejecutar el comando: ranksByUsername.top(10) El resultado se puede ver en la figura 31. Figura 31. Top 10 elementos del resultado. Fuente: El Autor. La velocidad de procesamiento siempre irá en función de algunas variables, como la cantidad de nodos del clúster, tamaño de la data a analizar, el hardware disponible de cada nodo del clúster, etc. 79 La tabla 3 muestra los resultados de tres iteraciones en las que lo que varió fue el hardware, la cantidad de nodos participantes en el clúster y la plataforma: Tabla 3. Iteraciones sobre Standalone Cluster-GraphX. Iteración # Nodos Cores (por nodo) RAM (por nodo) Dataset Algoritmo Tiempo de respuesta Plataforma PageRank Más de 45 minutos. Linux 5 millones de I1 1 2 512MB relaciones aproximadamente. 5 millones de 10 minutos I2 2 2 (4 total) 2GB relaciones PageRank Linux aproximadamente. aproximadamente. 5 millones de 3 minutos I3 1 12 10GB relaciones PageRank MAC aproximadamente. aproximadamente. Fuente: El Autor. 80 ANEXO H: CONFIGURACIÓN DE YARN SINGLE-NODE. Para la configuración YARN single-node es necesario ingresar al directorio en donde se descomprimió Hadoop, luego ir a la carpeta ―etc/hadoop‖. Dentro de ella se encuentran varios archivos, de los cuales se debe modificar: hadoop.env.sh: # set to the root of your Java installation export JAVA_HOME={your java home directory} # set to the root of your Hadoop installation export HADOOP_PREFIX={your hadoop distribution directory} core-site.xml: <configuration> <property> <name>fs.defaultFS</name> <value>hdfs://localhost:9000</value> </property> </configuration> hdfs-site.xml: <configuration> <property> <name>dfs.replication</name> <value>1 </value> </property> <property> <name>dfs.namenode.name.dir</name> <value>file:/usr/local/hadoop_tmp/hdfs/namenode</value> </property> <property> <name>dfs.datanode.data.dir</name> <value>file:/usr/local/hadoop_tmp/hdfs/datanode</value> </property> </configuration> mapred-site.xml: <configuration> <property> <name>mapreduce.framework.name</name> <value>yarn</value> </property> </configuration> 81 yarn-site.xml: <property> <name>yarn.nodemanager.aux-services</name> <value>mapreduce_shuffle</value> </property> <property> <name>yarn.nodemanager.auxservices.mapreduce.shuffle.class</name> <value>org.apache.hadoop.mapred.ShuffleHandler</value> </property> 82