Hoy de nuevo les traigo a ustedes un post relacionado con Apache Drill. Como les comenté en el post anterior, apache drill funciona con plugins, donde en cada uno de estos se define como se establece la conexión. Por ende en este caso nosotros deberemos crear un plugin para conectarnos con MySQL. De nuevo utilizaremos el modo embebed de la herramienta por lo cual para iniciar deberemos ir a la carpeta bin dentro de la instalación de apache drill y ejecutar el archivo drill-embedded en el caso de aquellos que estén utilizando Windows deben ejecutar sqlline.bat.
Desde un navegador web nos vamos a la dirección
http://localhost:8047/storage
Ruta donde están los plugin de antemano definidos. Para crear nuestro nuevo plugin para conectarnos con MySQL nos iremos a la parte inferior y en el campo de texto le daremos el nombre del nuevo plugin a crear, en nuestro caso lo llamaremos mysql y pulsaremos el botón “Create”.
create plugin
Inmediatamente después en el campo “Configuration” introducimos el siguiente json eliminando el null que trae por defecto y pulsamos el botón “Create”
JavaScript
1
2
3
4
5
6
7
8
{
"type":"jdbc",
"driver":"com.mysql.jdbc.Driver",
"url":"jdbc:mysql://localhost:3306",
"username":"username",
"password":"mypassword",
"enabled":true
}
donde:
username: será el nombre de usuario que utilizamos para conectarnos a MySQL.
password: será el password que utilizamos para conectarnos a MySQL.
url: El host y el puerto al que nos conectamos en MySQL.
configuración del plugin
El siguiente paso es colocar jar driver mysql en la ruta <drill_installation_directory>/jars/3rdparty
Hay un último paso a llevar a cabo en la configuración, para que la definición del plugin se mantenga una vez hayamos reinciado el ordenador o iniciado una nueva sesión con drill.
Editaremos el fichero <drill_installation_directory>/conf/drill-override.conf y especificaremos la ruta donde se almacenarán las configuraciones (definiciones) que hagamos de los plugins por ejemplo:
JavaScript
1
2
3
4
5
6
7
8
9
10
11
drill.exec:{
cluster-id:"drillbits1",
zk.connect:"localhost:2181",
sys.store.provider:{
local:{
path:"/tmp/drill",
write:true
}
},
}
Una vez hecho esto si reiniciamos drill veremos en los storage el plugin de mysql. Por último para comprobar la definición del plugin solo necesitaremos efectuar una consulta por ejemplo utilizando el UI de apache drill de la forma:
SELECT * mysql.database_name.table_name
Al igual que con el post anterior una vez definido el plugin de mysql podremos efectuar consultas del tipo join que involucren una tabla en MySQL, un fichero CSV, un fichero JSON y otros.
Es un motor de consultas open-source para exploración de fuentes de datos con grandes volúmenes de datos. Apache drill nos permite realizar análisis de alto rendimiento sobre datos semiestructurados sin dejar de ofrecer la familiaridad y el ecosistema de la norma ANSI SQL. Apache drill a su vez posee integración con Hive y HBase.
Apache drill a menudo es comparado con Hive y con Impala, por su alto rendimiento por trabajar con ficheros .csv y .json, así como también porque por medio de estas podemos efectuar consultas en HBase, pero hay un aspecto donde drill sobresale y es que puede conectarse a otros gestores de bases de datos como por ejemplo MySQL y MongoDB.
¿Cómo conocí Apache drill?
Me topé con apache drill por casualidad en el 2015, debido a las circunstancias y dificultades con las que trabajábamos, teníamos ordenadores plataformas que no nos permitían instalar nada y como tarea teníamos que hacer cruce de información de grandes ficheros .csv con sistemas de bases de datos relacionales. Los ficheros .csv eran tan grandes que ni siquiera podíamos visualizarlos con excel ni con atom y apache drill termino siendo una herramienta estupenda para poder realizar exploración sobre los datos y eso que lo utilizamos en modo embebido en nuestro ordenadores.
Instalación
Apache drill tiene 2 tipos de instalación dependiendo si será en un cluster o si será en un único nodo, nosotros haremos la de un único nodo, la cual es muy sencilla ya que solo es necesario descomprimir el fichero descargado y ejecutar el fichero ./drill-embebed el cual esta en la carpeta /bin de nuestra instalación.
Este último paso abrirá una consola donde podremos ejecutar sentencias sql y además se levantará un cliente web al que podremos acceder desde cualquier navegador en la ruta http://localhost:8047
apache drill web client
Ahora vamos a empezar a jugar con drill, para ello crearemos un fichero json que denominaremos cliente_banco.json con los siguientes datos:
JavaScript
1
2
3
4
{"ID":"12121212","BANCO":"BANCO_A"}
{"ID":"12312312","BANCO":"BANCO_B"}
{"ID":"13131313","BANCO":"BANCO_C"}
{"ID":"23423423","BANCO":"BANCO_A"}
También crearemos un fichero csv con los datos de los clientes y lo llamaremos clientes.csv:
JavaScript
1
2
3
4
5
"ID","NOMBRE","APELLIDOS","PROVINCIA"
"12121212","MARIA","LIONZA","MADRID"
"12312312","JAIMITO","PEREZ","ALMERÍA"
"13131313","BRUNO","DIAZ","MALAGA"
"23423423","HARLEY","QUINN","BARCELONA"
Ahora que empiece la diversión, lo primero que haremos será consultar los datos del fichero clientes.csv como si fuera una tabla con SQL utilizando el cliente Web de drill, para ello será necesario ir a la ruta http://localhost:8047/query
Una vez allí ejecutaremos la siguiente sentencia:
SELECT * FROM dfs.ruta_fichero/clientes.csv
resultado query csv en drill
El resultado no se puede apreciar muy bien además que se ve que asume la cabecera del fichero csv como si fuese un registro, para mejorar esto, será necesario hacer una pequeña modificación en la configuración. Apache drill funciona con plugins donde se almacena toda la configuración de las conexiones con ficheros del filesystem, de gestores de bases de datos, tipo mongoDB, MySQL, etc. por ende será necesario que editemos la configuración del plugin de filesystem para que tome en cuenta la cabecera del fichero csv (NOTA: Aquí también podríamos configurar el tipo de separador ya sea “,”o “;” o “|” entre otros).
Para realizar la actualización de la configuración deberemos ir a la ruta http://localhost:8047/storage y hacer clic en el botón “Update” del plugin dfs.
storage
Allí veremos un json utilizado para la configuración y buscaremos el elemento “csv” dentro del objeto “formats” y le añadiremos el atributo “skipFirstLine”: true como se muestra en la siguiente imagen y procederemos a actualizar el plugin pulsando el botón “Update”.
configurando plugin dfs para que no tome en cuenta la primera linea del csv
Si intentamos de nuevo la consulta veremos como es obviada la cabecera del fichero csv, aunque aún no vemos el resultado como una tabla, para eso utilizaremos alias para identificar a cada columna al momento de efectuar la consulta de la siguiente forma:
SELECT columns[0] as ID, columns[1] as NOMBRE, columns[2] as APELLIDOS, columns[3] as PROVINCIA FROM dfs.ruta_fichero/clientes.csv
Obteniendo lo siguiente:
resultado de la consulta
Vamos a profundizar aún más y ahora realizaremos un join entre los datos del fichero csv y del fichero json, ejecutando la siguiente consulta:
SELECT tablaCSV.columns[0] as ID, tablaCSV.columns[1] as NOMBRE, tablaCSV.columns[2] as APELLIDOS, tablaCSV.columns[3] as PROVINCIA, tablaJSON.BANCO FROM dfs.ruta_fichero/clientes.csv tablaCSV
LEFT JOIN dfs..ruta_fichero/cliente_banco.json tablaJSON
ON tablaCSV.columns[0] = tablaJSON.ID
Obteniendo:
resultado del left join
Apache drill nos ofrece a su vez más posibilidades como por ejemplo crear tablas en formato parquet a partir de un json o de un fichero csv. Apache drill es una herramienta que me gusta mucho pero también cuenta con algún aspecto a mejorar, por ejemplo me gustaría poder utilizar la cabecera de un fichero csv como nombre de columna al efectuar consultas y esto no funciona del todo bien, de hecho hice unas pruebas y fue así como me percate de este pequeño error que estoy seguro (y espero) se solucione pronto.
Para que la cabecera de un archivo csv sea tomada en cuenta como nombre de columna de una tabla es necesario modificar la configuración del plugin dfs, al igual que lo hicimos antes para que no tomase en cuenta la primera fila del archivo, editando el formato csv así como en la siguiente imagen.
configurando dfs plugin para que reconozca la cabecera de los ficheros csv
De nuevo repitamos la consulta que hacíamos al principio:
SELECT * FROM dfs.ruta_fichero/clientes.csv
Vemos como de inmediato sin haber utilizado alias en la consulta el resultado es devuelto como una tabla
Si ahora repetimos la consulta veremos como la salida de los resultados ha cambiado, dándonos una perspectiva de que tenemos una tabla, utilizando la cabecera del fichero csv como la cabecera de la tabla de resultados
consulta de todos los campos
Además al igual que con ejemplos anteriores podemos efectuar join con otras tablas independientemente en el formato o fuente que se encuentren (son, csv, parquet, mysql, etc…), el problema (o error) esta cuando intentamos consultar por un campo en especifico alguno puede que no devuelva nada como por ejemplo si efectuamos la siguiente consulta:
SELECT ID, NOMBRE FROM dfs.ruta_fichero/clientes.csv
consulta de ID y NOMBRE
Esto me pareció tan extraño que intente jugar con distintos parámetros de configuración e incluso con la forma de realizar la consulta y no pude solventar este comportamiento por lo que publiqué este error en stackoverflow por si estaba haciendo algo mal y alguien podía echarme una mano.
No quiero que lo último los desanime a probar la herramienta ya que esta cuenta con muchas bondades que dan para redactar unas cuantas entradas más, espero que hayan podido seguir todos los ejemplos y tener una perspectiva de lo que podemos alcanzar con la herramienta.
ACTUALIZACIÓN 28-09-2016:
Al haber quedado con la inquietud del mal funcionamiento al ejecutar la consulta sobre el csv indicando como columnas la cabecera del fichero, me decidí a escribir a lista de usuarios de apache drill por si en dado caso me estaba topando con un bug (cosa extraña porque llevaría así al menos 3 releases) y ellos me han dado la respuesta, el problema estaba en el espacio en blanco inmediatamente después de la coma, por lo cual al reformular la consulta y hacerla de la siguiente manera funcionó a la perfección:
SELECT ID, ‘ NOMBRE’ FROM dfs.ruta_fichero/clientes.csv
Pero otra forma quizás más elegante aún es que se eliminase el espacio después de la coma en la cabecera del archivo csv, de esa manera basta con que coloquemos los nombres de las columnas sin necesidad de encerrarlas entre comillas al momento de formular la consulta.
SELECT ID, NOMBRE FROM dfs.ruta_fichero/clientes.csv
Sigo con mi pruebas con lo nuevo (y no tan nuevo de Spark 2), hoy comparto con ustedes una versión 2 de mi anterior post Estadística simple con Spark, pero en esta ocasión realizado con Spark 2.
¿Que tiene de nuevo esta versión?
Primeramente utiliza el módulo spark-csv lo cual nos hace más simple la carga del fichero en un Dataset. Segundo, que no manipulamos en ningún instante RDD alguno, sino que por el contrario estamos trabajando con DataFrames representados mediante la clase Dataset. Entre las cosas nuevas que contempla esta versión hecha en Spark 2 es que mientras antes al realizar un groupBy sobre un DataFrame esto nos devolvía un GroupedData ahora nos devuelve un RelationalGroupedData, esto debido a un cambio de nombre que se le ha dado a partir de esta nueva versión de Spark.
Esta nueva versión realizada con SparkSQL con Datasets tiene varias ventajas, la primera es simplicidad, es mucho mas simple, mas fácil de entender el código además de mas corto, de hecho con menos lineas obtuve más información que con la versión elaborada con RDD’s, es decir, es mas versátil. Por otro lado aunque hay que tener algo de nociones de conjuntos lo interesante es que esta versión esta libre de código SQL.
Hace pocos días salió la esperada versión 2 de Apache Spark y como algunos de ustedes saben es un framework que ahora mismo atrae mucho mi atención y como no pudo ser de otra forma hice un pequeño proyecto donde quiero ir colocando ejemplos sencillos de Spark con las nuevas (y no tan nuevas) cosas de Spark.
Para empezar comentarles que yo todavía no he utilizado sbt sino por el contrario uso maven como herramienta de construcción de proyectos. He aquí los primeros cambios necesarios para trabajar con spark 2, las dependencias correspondientes a la versión (indicadas en el pom.xml).
XHTML
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<dependencies>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.10</artifactId>
<version>2.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-sql_2.10</artifactId>
<version>2.0.0</version>
</dependency>
...
Entre los nuevos cambios de spark está que el punto de entrada para los programas spark ya no serán el hiveContext o sqlContext sino que han sido subsumidas en una clase llamada SparkSession. Las clases HiveContext y SQLContext se han mantenido para proporcionar retrocompatibilidad. Ejemplo
Scala
1
2
3
4
5
6
7
8
// En spark v1.6.2 <= lo hubieramos hecho asi
// val conf = new SparkConf().setMaster("local").setAppName("Simple Application")
// val sc = new SparkContext(conf)
// val sqlContext = new org.apache.spark.sql.SQLContext(sc)
valsparkSession=SparkSession.builder.
master("local")
.appName("Simple Application")
.getOrCreate()
Con el SparkSession haremos lo mismo que hacíamos con sqlContext por ejemplo obtener un Dataset
.option("header","true")// Use first line of all files as header
.option("inferSchema","true")// Automatically infer data types
.load("src/main/resources/datos.csv")
Otro punto importante ha sido la unificación de las clases Dataset y DataFrame (para Java y Scala) a partir de la versión 2.¿Qué significa esto? pues sencillamente que ahora solo existirá la clase Dataset, pero proporcionará la misma funcionalidad que nos daba la clase DataFrame, de hecho basta con comparar la API en la versión 1.6.2 y 2.0.0 y ver como los métodos de la clase DataFrame están ahora incluidos en la clase Dataset.
Dataset y Dataframe en Spark 2
Aquellos interesados en leer más acerca de Dataset y Dataframe visitar este link
Estos no son los únicos cambios en Spark, de hechos son muchos más, que se corresponden a optimizaciones a nivel de compilación y ejecución así como también a un nuevo parseador SQL, para leer mas acerca de lo nuevo en Spark 2 clic aquí.
Aqui les dejo en enlace al proyecto donde ire añadiendo clases y seguiré probando mas cosas nuevas de Spark.
Apache Storm es un framework de procesamiento distribuido de eventos. Empresas como twitter utilizaron Storm desde el 2011 aunque posteriormente lo reemplazó por Heron en el 2015.
Actualmente me encuentro trabajando en una aplicación construida con Apache Storm y quiero compartir con ustedes mi primer ejemplo con Apache Storm el cual es bastante simple pero cumplio su cometido que era el iniciarme en este framework y entender sus componentes principales.
Necesitaremos descargar rabbitMQ la versión 3.5.7.
Una vez hayamos instalado rabbitMQ (es solo cuestión de descomprimir) vamos a habilitar un plugin (un cliente web) donde podremos de forma sencilla monitorizar las colas, entonces nos ubicamos en la siguiente ruta ruta_instalacion_rabbitmq/sbin/ y desde allí ejecutamos el siguiente comando
./rabbitmq-plugins enable rabbitmq_management
Este comando habilitará el cliente web que nos permitirá monitorizar las colas, los exchanges incluso manipular las colas pudiendo ingresar elementos a las colas, sacar elementos e incluso purgar las colas. Paso siguiente iniciaremos el rabbitMQ con el siguiente comando:
./rabbitmq-server
Inmediatamente después desde un navegador nos dirigimos a la dirección http://localhost:15672
rabbitmq overview
Una vez allí crearemos una cola para hacer nuestro ejemplo y la llamaremos “data”.
agregar cola en rabbitmq
Ahora deberíamos ser capaces de ver la única cola de nuestro sistema. Clicando en ella podríamos incluso agregarle mensajes por medio de la interfaz gráfica (si lo desean hagan la prueba y verán como cada uno de los mensajes que agreguen se irán encolando), pero la inserción de mensajes en la cola lo haremos mediante un pequeño programa Java.
cola data
Ahora un poco de teoría para conocer acerca de Apache Storm.
¿Qué es Apache Storm?
Es un framework de computación distribuida en tiempo real, escrito en su mayoría en Clojure. Storm es similar a la forma como Hadoop ofrece un conjunto de primitivas generales para hacer el procesamiento por lotes, también ofrece un conjunto de primitivas generales para hacer cómputos en tiempo real. Storm es simple, se puede utilizar con cualquier lenguaje de programación.
Las aplicaciones de Storm son creadas como topologías en la forma de DAG (Directed Acyclic Graph) con spouts y bolts actuando como los vertices del grado. Las aristas en el grafo son llamados streams y dirigen la data de un nodo a otro. Juntos, la topología actúa como una tubería de transformación de datos.
Los spouts son fuentes de flujo (streams) en una topología. Los spouts generalmente leerán tuplas desde una fuente externa y las emiten dentro de la topología.
Un bolt es donde se realiza todo el procesamiento de una topología, pueden hacer cualquier cosa, desde filtrado, funciones, agregaciones, joins, comunicarse con bases de datos y mucho más.
El ejemplo que hice y compartiré a continuación con ustedes será bastante simple, estará constituido por un spout que leerá de una cola rabbitmq (la cola data que creamos anteriormente) y ese mensaje lo insertará en la topología para posteriormente al recibirlo el bolt mostrarlo por linea de comandos (ya luego si ustedes lo desean lo que podrían hacer es que en vez de mostrarlo por linea de comandos volcar ese mensaje en otra cola de rabbitmq).
El programa java que se encarga de insertar mensajes a la cola
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
packagecom.josedeveloper.rabbitmq;
importjava.io.IOException;
importjava.util.concurrent.TimeoutException;
importcom.rabbitmq.client.Channel;
importcom.rabbitmq.client.Connection;
importcom.rabbitmq.client.ConnectionFactory;
publicclassSendMessagesToRabbit{
publicstaticfinalStringmessage="MENSAJE DE PRUEBA";
Para ejecutar nuestro ejemplo y verlo funcionando debemos ejecutar 2 clases (el orden sería indistinto):
SendMessagesToRabbit
RabbitMQTopologyExample
Al ejecutar la clase SendMessagesToRabbit, podremos ver en el cliente Web de RabbitMQ como la cola tendrá 10000 mensajes encolados. Al ejecutar la topología (ejecutando la clase RabbitMQTopologyExample) podremos ver como los mensajes se van desencolando y a su vez por linea de comandos (por ejemplo de nuestro editor) veremos los mensajes que en teoría el bolt leyó y procesó.
Espero que les sea de utilidad y disfruten con este framework, desde mi punto de vista es sencillo y funciona bien, incluso la nueva herramienta que utiliza Twitter posee retrocompatibilidad con Storm por lo cual se podría empezar con un ejemplo de este tipo.
Actualmente me encuentro desarrollando mi proyecto final de máster, el cual consiste en crear un modelo de aprendizaje automático que arroje predicciones acerca de partidos de futbol de la liga de primera división española. Para ello he necesitado entre otras cosas tener los resultados de todas las jornadas de las ultimas ligas. Aunque recientemente conseguí un paquete de R (enlace) que contenía los resultados desde 1929, este no me proporcionaba toda la información que yo buscaba, así que me decidí por obtener yo mismo esa información sacándola de las paginas deportivas y es lo que quiero compartir con ustedes.
En un principio pense en hacerlo en python con la biblioteca lxml, pero haciendo una búsqueda rápida por Internet encontré un proyecto en Java llamado Jsoup y debo decir que este si me simplifico la tarea.
Primero como todos saben es necesario que demos un repaso a la estructura del documento que vamos a scrapear y confirmar que hay un patron.
Como pueden ver en la imagen, podemos detallar que todas las filas de las tablas de las jornadas comparten el atributo itemtype=”http://schema.org/SportEvent”, así que este fue el que utilicé para obtener todas las filas y a partir de allí obtener los nombres de los equipos, el resultado y el enlace para ir al detalle del partido.
System.out.println(localTeam+" vs "+visitorTeam+": "+localGoals+"-"+visitorGoals+" -> "+statsLink);
}
}
}
Par de cosas que quisiera comentar con respecto al código:
Podemos aplicar expresiones sobre elementos de antemano obtenidos, por ejemplo como se hizo para obtener los equipos que intervienen en el partido.
Existe otra forma además de la anteriormente explicada (usando expresiones) para obtener elementos del árbol DOM de la página Web, si damos un vistazo a la API de la biblioteca del partido, existe un método getElementsByAttributeValue, entonces para obtener el elemento score, este se pudo haber obtenido también de la siguiente manera
Elements score = match.getElementsByAttributeValue(“class”, “resultado resul_post”)
Por último si quisiéramos obtener mas datos por ejemplo del detalle del partido (ya que logramos obtener el url), esta biblioteca nos permite seguir navegando (haciendo conexiones), y sería cuestión de realizar otra conexión y de nuevo empezar a extraer elementos.
Document detalleDelPartido = Jsoup.connect(statsLink).get()
Aquí les dejo el enlace al repositorio GitHub y espero que les pueda ser de utilidad.
Hace unos 20 días lei un articulo titulado “Simple Data Analysis Using Spark” (no publico el enlace ya que el mismo desapareció de dzone de la zona de Big Data y el mismo blog ya no existe, corroborarlo buscando por Internet), lo interesante de este articulo es que el autor hacía cálculos de estadística simple, es decir, calculaba, media, máximo y mínimo, y fue casualidad que justo en ese momento acaba de leer acerca de las operaciones numéricas de los RDD, es esta la razón que me movió a querer hacer un ejercicio similar, con estadística simple pero quería hacerlo con una información que yo considerara valiosa.
Fue entonces que me decidí a buscar alguna fuente de open data española, ya que quería arrojar u obtener datos reales, o no se quizás quería sencillamente obtener algo significativo que se acercara a una tarea real, fue así que llegue al Portal de datos abiertos de la comunidad de Madrid y después de revisar el catalogo me decidí por el padrón municipal, un fichero csv de 22 MB.
println("Media de personas por distrito: "+media2.toInt)
println("Desviación estandar de personas por distrito: "+stddev2.toInt)
println("Num maximo de personas en un distrito: "+max2.toInt)
println("Num minimo de personas en un distrito: "+min2.toInt)
defgetIntValue(s:String):Integer={
valvalue=s.substring(1,s.length-1)
if(value.isEmpty)
return0
returnInteger.parseInt(value)
}
}
Hay una cosa que quiero resaltar, Lo simple y corto del código en Scala, tanto para la definición de la clase Padron como en las transformaciones hechas en los RDD, ya Scala esta en mi lista de cosas por aprender porque se que con Java hubiese sido el doble de código.
Por último les dejo parte de la información obtenida, la lista ordenada de población por distrito:
BARAJAS: 46166
VICALVARO: 69709
MORATALAZ: 94785
VILLA DE VALLECAS: 101011
MONCLOA-ARAVACA: 116581
RETIRO: 118390
CENTRO: 131805
USERA: 133579
CHAMBERI: 137454
VILLAVERDE: 141457
CHAMARTIN: 142334
SALAMANCA: 143123
ARGANZUELA: 151061
TETUAN: 152142
SAN BLAS-CANILLEJAS: 153303
HORTALEZA: 176320
CIUDAD LINEAL: 212626
PUENTE DE VALLECAS: 227183
LATINA: 234842
FUENCARRAL-EL PARDO: 234883
CARABANCHEL: 242032
¿Te ha parecido interesante? ¿Qué le agregarías o quitarías al código?
Si quieres acceder al GitHub donde he colgado el código pincha aquí
Hace algunas semanas atrás que empezamos a trabajar con apache spark en el máster, brevemente les contare mis impresiones desde mi punto de vista como principiante.
Apache spark me gusto, ¿por qué? porque se puede programar en Scala (además de Python y Java), la API de Scala lo simplifica mucho y la cantidad de código a teclear es (considerablemente) menor a la necesaria para hacer la misma tarea en Java, aunque aquí debo hacer un paréntesis, ya que con la entrada de Java 8 y las lambda expresión la cantidad de código será menor pero insisto la API de Scala a mi modo de ver lo hace mas sencillo.
Nos permite hacer operaciones con mucha data (quizás no Big Data, es decir no hablamos de TeraBytes) sin necesidad de usar Hadoop, me gustaría hacer hincapié en esto ya que muchos piensan que Big Data es Hadoop y NO, no es así, mi concepto de Big Data es un poco mas amplio y contempla mas cosas, aquí me refiero específicamente a la API MapReduce de Hadoop la cual es mas complicada de usar que la de Spark, no obstante si necesitamos trabajar con una cantidad de datos considerable que requiera del uso de HDFS, podemos desde Spark acceder a este sistema de archivo u algún otro como por ejemplo Amazon S3.
Por último decirles que Spark es mas rapido, esto se debe a su arquitectura, ya que este trabaja en memoria (todo en memoria si tiene la capacidad de cargar todos los datos por completo) y pues si llegamos a hacer varias tareas (lo que técnicamente sería reutilizar los RDD ya guardados en memoria) con los datos en memoria es cuando mas jugo se le sacará a Spark.
Sinceramente si alguien discrepa de mi o coincide me entusiasmaría mucho que comparta su opinión ya que todo este mundo que envuelve el Big Data me tiene super enganchado.
Ahora bien vamos con los ejemplos, estas formaban parte de la primera tarea de Spark que tuvimos que realizar, y consiste en 2 ejemplos:
Dado un fichero de texto en formato csv con información de medallistas olímpicos, obtener el numero de medallas por edad.
Dado el mismo fichero de texto anterior, y un esquema de puntuación por tipo de medalla obtener un ranking de medallistas olímpicos.
Una última cosa que es bueno saber para aquellos que como yo están empezando con Spark y sus RDD, Los RDD tienen 2 tipos de operaciones: transformaciones y acciones, las primeras son operaciones que como resultado nos devuelven otro RDD y las acciones son aquellas que hacen “algo” sobre los datos como por ejemplo el foreach de mi código, utilizado para mostrar por pantalla los valores finales, además los RDD (como hasta ahora lo entiendo) son las instrucciones a realizar sobre los datos, mas no almacenan la información, además estás instrucciones no se realizan de inmediato, sino que al contrario estos tienen un funcionamiento lazy, esto significa que se ejecutan cada vez que se realiza una operación de tipo acción.
Otra sugerencia, no duden en cacharrear con la consola de spark, de hecho el primer ejercicio lo llegue a hacer por la consola (sin los JavaBeans) y el practicar por aquí si que ayuda a conocer los operaciones a utilizar sobre los RDD.
Aquellos interesados en descargar el código, les dejo la dirección del ejercicio en mi repositorio github
El esqueleto del ejercicio esta en el repositorio del que fue nuestro profesor y pueden acceder a el haciendo clic aquí.
Cualquier material, idea o contenido que quieres compartir, no dudes en hacerlo, ya que bien recibido será. Ahora si para cerrar les dejo el enlace a un libro que hasta ahora me esta pareciendo muy bueno para aprender Spark (además con ejemplos elaborados en Java, Scala y Python).
Hace una semana en una clase del máster mas enfocada a negocio, retos y oportunidades del Big Data, hicimos un ejercicio bastante interesante, este consistió en que cada uno de nosotros brevemente plasmara su definición de Big Data, donde podría aplicarse y que beneficios podría arrojarnos.
Pudimos ver las definiciones de algunos compañeros, coincidir y discrepar en algunos puntos pero para mí fue una actividad muy enriquecedora sin importar si coincidíamos o no, es por eso que comparto con ustedes mi definición de Big Data.
¿Qué es Big Data?
Big Data contempla las nuevas herramientas, tecnologías y (nuevos) los conceptos relacionados con la adquisición de (mucha) data (volumen), de distinto tipo (variedad) que a su vez podría estar no estructurada, con unos aspectos opcionales pero que también puede marcar la diferencia para definirlo como “really Big Data” como la movilidad (por ejemplo la adquisición de información mediante IoT o dispositivos móviles) y el tiempo real. De hecho contemplo el Big Data como unas 2 vertientes que pueden o no trabajar en conjunto:
Ingeniería: Enfocado en el uso de las herramientas por ejemplo al tratar verdaderamente mucha data con poco o nada de análisis, un rol de esta vertiente sería el Data Arquitect, esa persona encargada de manipular estructurar los datos, manipularlos, masticarlos y dejarlos bien preparados para aquellos encargados de hacer análisis sobre los datos, esta persona trabajaría con Hadoop, Pig, Spark.
Científica: Donde sin que estrictamente se tenga que trabajar con muchísima data (podría ser tanto small Data como Big Data) se lleva a cabo análisis mayormente de tipo estadístico como análisis predictivos, construyendo modelos, un rol de esta vertiente sería la del Data scientist, esa persona encargada de hacer data mining, machine learning, etc.
Y ¿yo qué quiero? ¿qué busco?
YO aspiro a convertirme en un Big Data Architect y seguir aprendiendo y profundizando mis conocimientos en Data mining, Machine learning, estadísticas e investigación de operaciones para forjarme un perfil mas científico.
¿Qué es lo que mas me ha interesado?
Aprendizaje automático (machine learning) y los nuevos enfoques para el procesamiento y almacenamiento de grandes volúmenes de datos (Spark, Flink, Hadoop, Cassandra, HBase).
¿Donde creo que podría aplicarse?
A nivel de ingeniería para almacenamiento por ejemplo de data del hogar (IoT), por ejemplo un termostato inteligente y configurable donde poder gestionar a través de una plataforma de Internet poder gestionar cuando se encienda/apague la calefacción, ver histórico de funcionamiento de la calefacción y sobre estos datos hacer análisis estadísticos.
¿Qué beneficios podría arrojar ?
En base al ejemplo anterior Dinero (ahorro de energía siguiendo con el ejemplo del termostato) o clientes (sistemas de recomendación de productos), otros casos serian por ejemplo tiempo (aprendizaje automático para la elaboración de prestamos preconcebidos o análisis de un cliente al momento de solicitar una hipoteca o préstamo por internet).
Ahora bien, una vez conocido mi concepto de Big Data ¿Coincides con mi definición? ¿discrepas?, ¿Cual es tu concepto del Big Data?
Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.
