Inges5ón%y%Análisis%de%datos%con%Hadoop%... · 2016-01-25 · – Oracle% – MySQL% – Teradata...

Fco. Javier Lahoz Sevilla

Inges5ón y Análisis de datos con Hadoop

•  Parte 1. Inges5ón de datos –  ¿Como cargar datos en Hadoop? –  Recolección, agregación y carga de eventos con Flume –  Transferencia de bases de datos relacionales con Sqoop

•  Parte 2. Análisis de datos –  ¿Como analizar datos en Hadoop? –  Análisis de grandes volúmenes de datos a través de Hive –  Procesamiento de datos mediante un lenguaje de alto nivel con Pig

•  Parte 3. Casos prác5cos en AWS –  Importación de tablas relacionales y explotación con Pig –  Recolección y análisis de Logs con Hive –  Captura y análisis de TweSs con Hive



¿Como cargar datos en Hadoop?

•  Una vez que se ha diseñado el despliegue de un cluster

el siguiente punto a considerar es como se van a cargar los datos.

•  Existen varias herramientas o productos para recolectar y cargar información: –  Manualmente –  Productos comerciales –  Herramientas Open Source



•  Se pueden recolectar datos de dis5nta variedad:



•  Para poder capturar este variedad de datos surge la necesidad de dis5ntas herramientas:

–  Flume, es una herramienta distribuida, fiable y escalable para la recolección, agregación y carga de grandes can5dades de datos.

–  Sqoop, está diseñada para transferir datos de manera eficiente y escalable de bases de datos relacionales a Hadoop.


Inges5ón con Flume

•  Flume 5ene una arquitectura simple y flexible basada en el streaming de datos.

•  Es tolerante a fallos y escalable.

•  Se basa en una configuración descentralizada basada en fichero planos.


•  Arquitectura. La arquitectura de Flume está basada en agentes:

Agente

Inges5ón con Flume


Source Sink

Channel

Datos Datos

Inges5ón con Flume

•  Arquitectura. Los agentes también se pueden conectar entre ellos:


Inges5ón con Flume

•  Arquitectura. Y también se pueden u5lizar para recolectar datos en capas:


Inges5ón con Flume

•  Veamos un ejemplo ilustra5vo de la configuración de una agente: agente.sources=misource agente.channels=micanal agente.sinks=misink

agente.sources.misource.type = <5po source> agente.sources.misource.<propiedad 5po source> = <propiedad source> agente.sources.misource.channels = micanal agente.sinks.misink.type = <5po sink> agente.sinks.misink.<propiedat 5po sink> = <propiedad sink> agente.sinks.misink.channels = micanal agente.channels. micanal.type = <5po channel>


Inges5ón con Flume

•  Veamos un ejemplo ilustra5vo de la configuración de una agente: agente.sources=misource agente.channels=micanal configuración agente.sinks=misink global

agente.sources.misource.type = <5po source> agente.sources.misource.<propiedad 5po source> = <propiedad source> agente.sources.misource.channels = micanal agente.sinks.misink.type = <5po sink> agente.sinks.misink.<propiedat 5po sink> = <propiedad sink> agente.sinks.misink.channels = micanal agente.channels. micanal.type = <5po channel>


Inges5ón con Flume


agente.sources.misource.type = <5po source> agente.sources.misource.<propiedad 5po source> = <propiedad source> configuración agente.sources.misource.channels = micanal de la fuente agente.sinks.misink.type = <5po sink> agente.sinks.misink.<propiedat 5po sink> = <propiedad sink> agente.sinks.misink.channels = micanal agente.channels. micanal.type = <5po channel>


Inges5ón con Flume


agente.sources.misource.type = <5po source> agente.sources.misource.<propiedad 5po source> = <propiedad source> agente.sources.misource.channels = micanal agente.sinks.misink.type = <5po sink> agente.sinks.misink.<propiedat 5po sink> = <propiedad sink> configuración agente.sinks.misink.channels = micanal del de8no agente.channels. micanal.type = <5po channel>


Inges5ón con Flume


agente.sources.misource.type = <5po source> agente.sources.misource.<propiedad 5po source> = <propiedad source> agente.sources.misource.channels = micanal agente.sinks.misink.type = <5po sink> agente.sinks.misink.<propiedat 5po sink> = <propiedad sink> agente.sinks.misink.channels = micanal agente.channels. micanal.type = <5po channel> canal


Inges5ón con Flume

•  Comenzaremos viendo algunos de los dis5ntos sources: –  spooling directory: escanea los ficheros de entrada en un determinado directorio y lo envía como eventos. Propiedades: •  type = spooldir •  channels = canal •  spoolDir = directorio del FileSystem para el cual se escanearán los ficheros

•  fileSuffix = sufijo que se le pondrá al fichero escaneado

–  exec: ejecuta comandos del sistema opera5vo. Se suele u5lizar para capturar cada nuevo registro de un fichero con ‘tail’. Propiedades: •  type = exec •  Channels = canal •  command = comando a ejecutar


Inges5ón con Flume

–  syslog: mecanismo u5lizado para capturar los logs del sistema opera5vo. Propiedades: •  type = syslogtcp/syslogupd •  channels = canal •  host = host o IP a unirse •  port = puerto a unirse

–  avro: se u5liza para comunicar agentes de flume a través de Avro. Propiedades: •  type = avro •  channels = canal •  bind = host o IP donde escucha los eventos •  port = puerto donde escucha los eventos


Inges5ón con Flume

•  Se puede dar más funcionalidad a los sources a través de Interceptores. –  Los interceptores 5enen la capacidad de poder modificar los eventos cuando se capturan o incluir más información, por ejemplo, el nombre del host, el 5mestamp o enviar valores está5cos.

–  Además de los interceptores por defecto que 5ene Flume también es posible desarrollarlos a medida, por ejemplo, para realizar transformaciones.


Inges5ón con Flume

•  Seguiremos viendo algunos Sinks: –  hdfs: para escribir los eventos en HDFS.

Propiedades: •  type = hdfs •  channels = canal •  hdfs.path = directorio del HDFS donde se escribirá •  hdfs.filePrefix = nombre del fichero que será creado (por defecto, FlumeData)

–  avro: des5no para conectar agentes flume con source Avro usados en recolectores, por ejemplo. Propiedades: •  type = avro •  channels = canal •  hostname = host o ip donde enviará los eventos •  port = puerto donde enviará los eventos


Inges5ón con Flume

–  HBase: para escribir los eventos en HBase. Propiedades: •  type = hbase •  channels = canal •  table = el nombre de la tabla a escribir •  columnFamily = column family donde se escribirá

–  Fill Roll: para escribir los eventos en el File System. Propiedades: •  type = file_roll •  channels = canal •  sink.directory = el nombre del directorio donde se escribirán los eventos.


Inges5ón con Flume

•  Por úl5mo veremos los dis5ntos Channels: –  memory: los eventos son almacenados en memoria.

Propiedades: •  type = memory •  capacity = máximo número de eventos cargados en el canal

–  file: los eventos se persis5rán en ficheros. Propiedades: •  type = file •  checkpointDir = directorio donde se almacenarán los checkpoint •  dataDirs = directorios donde guardarán los ficheros de log (serpados por comas)


Inges5ón con Flume

•  Ahora veamos un ejemplo real de configuración de una agente y como se ejecutaría: agente.sources=misource prueba_agente.conf agente.channels=micanal agente.sinks=misink

agente.sources.misource.type = spooldir agente.sources.misource.spoolDir = /var/log/apache/ agente.sources.misource.channels = micanal agente.sinks.misink.type = hdfs agente.sinks.misink.hdfs.path = hdfs://hadoop.master:9000/tmp/ agente.sinks.misink.channels = micanal agente.channels. micanal.type = memory Ejecución à flume-‐ng agent -‐n agente -‐c conf -‐f conf/prueba_agente.conf -‐ Dflume.root.logger=INFO,console


Carga de datos con Sqoop

•  Con Sqoop se puede importar datos de bases de datos relacionales a HDFS, Hive o HBase. Algunas bases de datos serían: –  Oracle –  MySQL –  Teradata –  DB2 –  ….

•  Además de puede exportar ficheros de HDFS a bases de datos relacionales.



•  Funcionamiento de Sqoop: –  U5liza JDBC, por lo tanto, sólo necesitará el driver correspondiente para poderse conectar a la base de datos, o conectores de proveedores de bases de datos que mejoran el rendimiento.

–  Sqoop se conectará a la BBDD para analizar la tabla a importar. –  Cuando conoce el volumen de la información genera una clase java para importar los datos que se ejecutará a través de jobs map-‐only (no se ejecuturá fase Reduce).

–  Por defecto se ejecutarán cuatro mappers procesando cada uno un cuarto de los datos a importar.

–  Todas las máquinas tendrán que tener permisos para acceder a la base de datos.



•  Caracterís5cas de Sqoop: –  Sqoop puede importar una tabla o una esquema de base de datos.

–  También se pueden filtrar los datos de una tabla, por ejemplo, para cargar incrementales basados en una fecha de alta o modificación.

–  Permite proyectar una tabla recuperando sólo los campos requeridos.

–  Sqoop puede importar los datos en un fichero del HDFS, en una tabla de Hive o de HBase.



•  Sqoop se ejecuta a través de lineas de comandos: –  sqoop <opcion> <argumentos>

•  Opciones para importar: –  sqoop import -‐-‐connect jdbc:mysql://<db_ip>/<db_name> -‐-‐username <db_user> -‐-‐password <db_pass> -‐-‐table <db_table> -‐-‐target-‐dir <hdfs_path>

–  sqoop import -‐-‐connect jdbc:mysql://<db_ip>/<db_name> -‐-‐username <db_user> -‐-‐password <db_pass> -‐-‐table <db_table> -‐-‐hive-‐import



•  Más opciones: –  sqoop import -‐-‐driver com.ibm.db2.jcc.DB2Driver -‐-‐connect jdbc:db2://<db2_ip>:50000/<db2_name> -‐-‐username <db2_user> -‐-‐table <db2_table> -‐-‐target-‐dir <hdfs_path>

–  sqoop import -‐-‐column “a,b,c,d” -‐-‐where “a>100 and b <10” -‐-‐split-‐by a -‐-‐hive-‐import -‐-‐create-‐hive-‐table -‐-‐hive-‐table <db_hive_table>

–  sqoop import -‐-‐query 'SELECT a.*, b.* FROM a JOIN b on (a.id == b.id) WHERE $CONDITIONS’ -‐-‐split-‐by a.id -‐-‐target-‐dir <hdfs_path>




•  Parte 3. Casos prác5cos en AWS –  Importación de base de dato y explotación con Pig –  Recolección y análisis de Logs con Hive –  Captura y análisis de TweSs con Hive



¿Como analizar datos en Hadoop?

•  Cuando ya tenemos datos cargados en nuestro Cluster de Hadoop existen dis5ntas herramientas para analizar los datos. Se podrá u5lizar cada una de ellas según los conocimientos técnicos: –  Java –  Scala –  Python –  SQL

•  También existen herramientas OpenSource y comerciales que, mediante workflows, nos permiten analizar los datos.



•  Existen diversas tecnologías para analizar los datos según los lenguajes vistos anteriormente. Por ejemplo: –  MapReduce, framework desarrollado en Java para procesamiento paralelo de bajo nivel. Requiere tener conocimientos del framework y de Java.

–  Spark, para procesamiento paralelo en memoria. Se puede implementar en Scala, Python y Java, permi5endo analizar datos a través de SparkSQL y SparkStreaming, entre otros.

–  Hive, abstraccion por encima de Hadoop donde ejecuta procesos MapReduce mediante un interfaz SQL.

–  Pig, lenguaje de alto nivel para el procesamiento de MapReduce mediante flujos de datos.



•  Nosotros nos vamos a centrar en las siquientes herramientas: –  Hive es un sistema de almacen de datos (data warehouse) capaz de seleccionar y ges5onar grandes conjuntos de datos almacenados en HDFS.

–  Pig es una plataforma para el análisis de grandes conjuntos de datos que consiste en un lenguaje de alto nivel para expresar programas de análisis de datos.




•  Parte 3. Casos prác5cos en AWS –  Importación de base de dato y explotación con Pig –  Recolección y análisis de Logs con Hive –  Captura y análisis de TweSs con Hive



Análisis de datos con Hive

•  Hive es us sistema de almacen de datos (data warehouse) capaz de seleccionar y ges5onar grandes conjuntos de datos almacenados en HDFS.

•  Hive es un interfaz o abstracción para el acceso a los datos por encima de Hadoop accediendo a los datos del HDFS y procesándolos con MapReduce.

•  Se implementa en SQL (HiveQL)



•  Hive NO es una base de datos y usa los recursos de Hadoop para almacenar y procesar.

•  Sólo implementa un subconjunto del estandard SQL.

•  Actualmente no permirte Inserts, Updates y Deletes filtrados.

•  No soporta transacciones ni índices.

•  Tiene latencias grandes (por el uso de MapReduce).



•  Casos de uso: –  Almacenamiento histórico ges5onado con par5ciones, por ejemplo, con fecha (año, mes, día, hora,…)

–  Data Lakes: grandes almacenes de datos donde no toda la información es suscep5ble de explotar. Se va almacenando y se le dará estructura cuando sea necesario analizarla.

–  Para repor5ng tradicional a través de herramientas de BI. –  Para analí5ca avanzada a través de paquetes estadís5cos, como por ejemplo, R.



•  Arquitectura de Hive:

–  Hive usa un schema “on read” lo que implica que no se validan los datos cuando se cargan o se insertan y pueden no ser correctos cuando se consultan devolviendo valores NULL.

–  Los datos se almacenan en ficheros dentro del HDFS en el siguiente path y se pueden consultar directamente mediante comandos hdfs (hdfs dfs –ls <hdfs_path>):

/user/hive/warehouse/<db_name>.db/<db_table>/



–  Los metadatos (estructuras) se almacenan en el Metastore que está compuesto por un servicio y un repositorio. Hay varios 5pos de metastore:

•  Metastore embebido. Configurado por defecto en Hive donde el repositorio es una base de datos Derby almacenada localmente en el disco.


Driver Metastore Derby

JVM


•  Metastore local. Permite tener varias sesiones de Hive simultaneamente (modo cliente/servidor) pero el Metastore sigue estando en una JVM.


Driver Metastore

Postgre SQL

JVM

Driver Metastore

JVM


•  Metastore remoto. Consiste en tener el servicio metastore en un proceso independiente que permite controlar de forma más segura el acceso al repositorio.


Driver

Metastore Postgre SQL

JVM

Driver

JVM


•  Configuración de Hive: –  Similar a Hadoop, Hive 5ene varios ficheros de configuración:

•  hive-‐env.sh, para la configuración del entorno y la localización de Hadoop, por ejemplo.

•  hive-‐site.xml, donde se parametrizan las propiedades de hive, como por ejemplo, el 5po de metastore a u5lizar, seguridad, memoría asignada a los jobs, auten5cación, ficheros de logs, entre otros posibles parámetros. Por defecto se cargará la configuración del fichero hive-‐default.xml.template.



•  Tipos de datos en Hive: –  Tipos simples:

•  STRING •  BIGINT •  INT •  SMALLINT •  FLOAT •  DOUBLE •  DATE •  BOOLEAN

–  Tipo Complejos: •  ARRAY (<String>) •  MAP (<String,int>) •  STRUCT (<campo1:5po, campo2:5po, …>)



•  Ges5ón de tablas con Hive: –  Vamos a empezar viendo como se puede crear una base de datos:

CREATE (DATABASE|SCHEMA) [IF NOT EXISTS] database_name [COMMENT database_comment] [LOCATION hdfs_path]

[WITH DBPROPERTIES (property_name=property_value, ...)];

Por ejemplo:

CREATE DATABASE test;



–  Podemos con5nuar creando una tabla:

CREATE TABLE [IF NOT EXISTS] <db_table> (<db_field1> type,<db_field2> type,…) ROW FORMAT DELIMITED FIELDS TERMINATED BY caracter; Por ejemplo:

CREATE TABLE test.test_table( id INT, cod INT, ind INT, desc STRING) ROW FORMAT DELIMITED FIELDS TERMINATED BY ', ';



–  Sería el momento de cargar datos: •  Mediante un LOAD desde un fichero local o de HDFS:

LOAD DATA (LOCAL) INPATH 'test.csv' (OVERWRITE) INTO TABLE test_table;

•  O copiando un fichero del hdfs al path de Hive:

hive>dfs –put test.csv /user/hive/warehouse/test.db/test_table/.

–  Otra opción es crear tablas con CTAS:

CREATE TABLE IF NOT EXISTS test.test_table_ctas AS SELECT id,cod,desc FROM test.test_table WHERE IND = '1';



–  También se pueden crear tablas externas con una sintaxis similar a la anterior pero indicando la ubicación del fichero:

CREATE EXTERNAL TABLE test.test_table_ext( id INT, cod INT, ind INT, desc STRING) ROW FORMAT DELIMITED FIELDS TERMINATED BY ', ' STORE AS TEXTILE LOCATION '/user/hadoop/table';



–  Para la organización de los datos y la op5mización en la explotación se deben usar par5ciones y buckets:

CREATE TABLE test.test_table_part( id INT, cod INT, ind INT, desc STRING) PARTITIONED BY (year int, month int,day int) ROW FORMAT DELIMITED FIELDS TERMINATED BY ‘,’;

ALTER TABLE test.test_table_part ADD PARTITION (year=2015, month=02,day=18); ALTER TABLE test.test_table_part ADD PARTITION (year=2015, month=02,day=19); ALTER TABLE test.test_table_part ADD PARTITION (year=2015, month=02,day=20); dfs -‐put test.csv /user/hive/warehouse/test.db/test_table_part/year=2015/ month=02/day=18;



–  En los casos anteriores los datos están estructurados pero también se pueden recuperar datos no estructurados, como json (caso de tweets) o semi estruturados, por ejemplo, los logs de una aplicación. Para estos casos no se puede u5lizar un separador ‘,’.

–  Con SerDe (Serialización Deserialización) se pueden definir expresiones regulares (regex) para dar estructura a los datos.

–  Para definir la expresión regular que vamos a ver a con5nuación se puede u5lizar: hSp://regexpal.com



Ejemplo para el log:

2014-‐10-‐21 21:47:11,256 INFO org.apache.hadoop.hdfs.server.namenode.NameNode: registered UNIX signal handlers for [TERM, HUP, INT] 2014-‐10-‐21 21:47:11,258 INFO org.apache.hadoop.hdfs.server.namenode.NameNode: createNameNode []

create table test.test_logs ( date date, hour string, type string, class string, mensaje string) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe' WITH SERDEPROPERTIES ("input.regex" =

"^(\\d{4}-‐\\d{2}-‐\\d{2})\\s(\\d{2}:\\d{2}:\\d{2},\\d{3})\\s(\\w+)\\s(\\w+.*):\\s(\\w+.*)"); LOAD DATA LOCAL INPATH ‘hive/test.log’ INTO TABLE test_logs;



•  Funcionalidad avanzada: En Hive se pueden realizar funciones avanzadas mediantes UDFs (User Defini5on Func5ons). Las UDFs son librerías que se pueden registrar en Hive para implementar, a través de Java, funciones avanzadas, como por ejemplo, cálculos aritmé5cos complejos o tratamiento avanzada de texto.



•  Op5mización de tablas con Hive: Al igual que las bases de datos relacionales como Oracle con Hive también se puede obtener el explain plain para poder op5mizar las consultas. Sólo es necesario añadir delante de la sentencia a ejecutar la palabra ‘explain’.

–  Se puede op5mizar las sentencias con Hints:

SELECT /*+ MAPJOIN(b) */ a.key, a.value FROM a JOIN b ON a.key = b.key




•  Parte 3. Casos prác5cos en AWS –  Importación de base de datos y explotación con Pig –  Recolección y análisis de Logs con Hive –  Captura y análisis de TweSs con Hive



Procesamiento de datos con Pig

•  Pig es una plataforma para el análisis de grandes conjuntos de datos que consiste en un lenguaje de alto nivel para expresar programas de análisis de datos.

•  En Pig se procesa la información como un flujo de datos encadenando las salidas y entradas de las operaciones.

•  Las operaciones realizadas en Pig se transforman en Jobs MapReduce que se ejecutan sobre el Cluster.



•  Arquitectura de Pig:

Pig es una capa que está por encima de Hadoop. Los flujos de datos se procesarán con MapReduce leyendo y escribiendo en HDFS u otras fuentes (MongoDB, Cassandra, HBase)


Pig Scrip5ng

MapReduce

HDFS


•  Configuración de Pig: –  Al igual que vimos para Hive en Pig también se pueden configurar dis5ntas propiedades en el fichero, pig.proper5es, como por ejemplo:

•  Ges5ón de la memoria •  Nivel de Log •  Perfil para UDFs •  Tipo de ejecución por defecto •  Librerias adicionales •  Directorio temporal para cachear •  Opciones de ejecución



•  Ejecución de Pig: –  Pig se puede ejecutar de las siguientes formas:

•  Molo local, ejecución en una instancia local. > pig -‐x local

•  Modo MapReduce (configurado por defecto) usará los recursos de hadoop para el procesamiento de las tareas. > pig (pig -‐x mapreduce)

•  Modo Tez, para ejecución de jobs con menor latencia. > pig -‐x tez

–  También existen diversas modos de ejecución: •  Interac5vo •  Batch: pig <script>.pig



•  Flujo de ejecución con Pig: Operaciones Relacionales


Datos Datos Load Data

Transform Data

Store Data



A = load ‘test.csv’ using PigStorage(‘,’);



Transform Data

Store Data



A = load ‘test.csv’ using PigStorage(‘,’); B = foreach A generate $0 as id;



Transform Data

Store Data



A = load ‘test.csv’ using PigStorage(‘,’); B = foreach A generate $0 as id; store B into ‘result.csv’



Transform Data

Store Data


•  Tipos de datos: –  Tipos simples:

•  int •  Long •  float •  double •  chararray •  bytearray •  boolean •  date5me

–  Tipo Complejos: •  map (<String,long>) •  tuple (<campo1,campo2, …>) •  bag (<tupla1, tupla2,…>)



•  Tipos de Operadores: –  Funciones de evaluación:

•  Count, Sum •  Avg, Max, Min •  Concat •  isEmpty •  Tokenize

–  Funciones matemá5cas: •  Abs, Cos, Sin, Exp, Log •  Floor, Ceil, Round


–  Funciones de Strings: •  IndexOf •  Lower, Upper •  Replace •  Substring •  Trim

–  Funciones para fechas: •  GetYear,GetMonth,… •  YearsBetween,… •  ToDate


•  Tipos de Operaciones Relacionales con Pig: –  Vamos a empezar viendo como se pueden cargar los datos: LOAD 'data' [USING func5on] [AS schema];

Ejemplo: A = LOAD 'test.csv' USING PigStorage(', ') AS (id:int, cod:int, ind:int,

desc:chararray); DUMP A;

Funciones disponibles: •  PigStorage, función por dejecto para campos delimitados. •  BinStorage, para cargar datos binarios •  TextLoader, para cargar datos no estructurados en UTF-‐8 •  JsonLoader, para cargar datos en formato JSON.



–  Con5nuaremos viendo como transformar los datos cargados:

•  FOREACH:

alias = FOREACH { gen_blk | nested_gen_blk } [AS schema]; Ejemplo: B = FOREACH A GENERATE id, cod, ind; DESCRIBE B;

•  FILTER: alias = FILTER alias BY <boolean expression>; Ejemplo: B = FILTER A BY ind == 1;



•  GROUP: alias = GROUP alias { ALL | BY expression} [, alias ALL | BY expression …] [USING 'collected'] [PARALLEL n]; Ejemplo: B = GROUP A BY ind; ILLUSTRATE B;

•  ORDER BY: alias = ORDER alias BY { * [ASC|DESC] | field_alias [ASC|DESC] [, field_alias [ASC|DESC] …] } [PARALLEL n]; Ejemplo: B = ORDER A BY id; DUMP B;



•  JOIN alias = JOIN alias BY {expression|'('expression [, expression …]')'} (, alias BY {expression|'('expression [, expression …]')'} …) [USING 'replicated' | 'skewed' | 'merge'] [PARALLEL n]; alias = JOIN le�-‐alias BY le�-‐alias-‐column [LEFT|RIGHT|FULL] [OUTER], right-‐alias BY right-‐alias-‐column [USING 'replicated' | 'skewed'] [PARALLEL n]; Ejemplos: B = LOAD 'test1.csv' USING PigStorage(';') AS (id:int,desc:chararray) C = JOIN A BY id, B BY id; DUMP C; C= JOIN A BY id LEFT, B BY id USING 'replicated'; DUMP C;



•  CROSS alias = CROSS alias, alias [, alias …] [PARALLEL n]; Ejemplo: C = CROSS A, B;

•  UNION alias = UNION alias, alias [, alias …]; Ejemplo: C = UNION A, B;

•  DISTINCT: alias = DISTINCT alias [PARALLEL n]; Ejemplo: B = DISTINT A;



–  Por úl5mo veremos como almacenar los datos transformados: STORE alias INTO 'directory' [USING func5on];

Ejemplo: STORE C INTO 'output' USING PigStorage('|');

Funciones disponibles: •  PigStorage, función por dejecto para campos delimitados. •  BinStorage, para almacenar datos binarios. •  PigDump, almacena los datos en formato UTF-‐8. •  JsonStorage, para almacenar datos en formato JSON.



•  Funcionalidad avanzada: En Pig tambien se pueden realizar funciones avanzadas mediantes UDFs (User Defini5on Func5ons).

•  Op5mización de flujos con Pig: Al igual que en Hive también se puede obtener el explain para el Debug de una operación relacional indicando Explain con la operación relizada Ejemplo: Explain B;


En este primer caso vamos a importar unas tablas con Sqoop para posteriormente procesarlas con Pig.


Importación de datos y explotación con Pig

•  Empezaremos instalando MySql en nuestro nodo master del Cluster: –  sudo apt-‐get install mysql-‐server –  sudo apt-‐get install libmysql-‐java –  Una vez instalado configuraremos la IP privada de la instancia de EC2 en el fichero de configuración

–  Reiniciar el servidor de la BBDD

•  Con5nuaremos instalando Sqoop en el mismo nodo: –  wget

hSp://apache.rediris.es/sqoop/1.4.5/sqoop-‐1.4.5.bin__hadoop-‐2.0.4-‐alpha.tar.gz

–  Crear SQOOP_HOME y modificar el PATH en el profile del usuario. –  Copiar el driver de conexión con MySql en las librerias de Sqoop

cp /usr/share/java/mysql.jar $SQOOP_HOME/lib



•  Seguiremos con la instalación de Pig: –  wget hSp://apache.rediris.es/pig/pig-‐0.14.0/pig-‐0.14.0.tar.gz

–  Crear PIG_HOME y modificar el PATH en el profile del usuario.

–  Modificar la configuración de Hadoop para incluir el historyserver añadiendo en el fichero mapred-‐site.xml: <property>

<name>mapreduce.jobhistory.address</name> <value>hadoop.master:10020</value> </property> –  Arrancar el proceso historyserver:

$HADOOP_HOME/sbin/mr-‐jobhistory-‐daemon.sh start historyserver



•  Una vez descargado e instalado el sw podremos empezar a preparar el caso:

–  Primero daremos permisos a las máquinas del cluster para que se puedan conectar con la BBDD:

mysql –u root -‐p GRANT ALL ON *.* to root@'EC2_IP_MASTER' IDENTIFIED BY 'password';

GRANT ALL ON *.* to root@'EC2_IP_SLAVE1' IDENTIFIED BY 'password'; GRANT ALL ON *.* to root@'EC2_IP_SLAVE2' IDENTIFIED BY 'password’; GRANT ALL ON *.* to root@'EC2_IP_SLAVE3' IDENTIFIED BY 'password'; GRANT ALL ON *.* to root@'EC2_IP_SLAVE4' IDENTIFIED BY 'password';



–  Generaremos los ficheros que vamos a cargar a través del generador de datos, GeneradorDatosCurso.java

–  Con5nuaremos creando las tablas en la BBDD y cargamos los ficheros.

use test; create table clientes ( cliente int(10) not null, nombre char(20), apellido char(20), nif char(10), telefono char(12), pais char(3), sexo char(1), mes int(2)not null, anio int(2) not null, consumo float, importe float, PRIMARY KEY (cliente,anio,mes)); LOAD DATA INFILE 'Clientes.csv' INTO TABLE clientes FIELDS TERMINATED BY ',';



–  Con5nuaremos creando las tablas en la BBDD y cargamos los ficheros. create table contratos ( contrato int(10) not null, cliente int(10) not null, producto int, 5tular char(40), fecha_alta char(10), mes int(2) not null, anio int(4) not null, consumo float, importe float, PRIMARY KEY (contrato,cliente,anio,mes)); LOAD DATA INFILE 'Contratos.csv' INTO TABLE contratos FIELDS TERMINATED BY ',';



•  Ya estamos en condiciones de comenzar a importar los datos y ejecutar los scripts de Pig:

–  Ejecutar el comando de importación de las tablas mediante sqoop:

sqoop import -‐-‐connect jdbc:mysql://hadoop.master/test -‐-‐table clientes -‐-‐username root -‐-‐password password -‐-‐target-‐dir /user/ubuntu/clientes sqoop import -‐-‐connect jdbc:mysql://hadoop.master/test -‐-‐table contratos -‐-‐username root -‐-‐password password -‐-‐target-‐dir /user/ubuntu/contratos

–  Podemos unificar los ficheros parciales generados: hdfs dfs -‐text clientes/part* | hdfs dfs -‐put -‐ Clientes_bbdd hdfs dfs -‐text contratos/part* | hdfs dfs -‐put -‐ Contratos_bbdd



–  Desarrollaremos los scripts de Pig que analizarán los datos importados.

clientes = LOAD '/user/ubuntu/Clientes_bbdd' USING PigStorage(',') AS (id_cliente:long, nombre:chararray, apellido:chararray, nif:chararray, telefono:long, nacionalidad:chararray, sexo:chararray, mes:int, anio:int, consumo:float, importe:float);

clientes_nac_sexo = GROUP clientes BY (nacionalidad,sexo);

group_clientes = FOREACH clientes_nac_sexo GENERATE group.nacionalidad, group.sexo, SUM(clientes.consumo) as consumo_nac_sexo, SUM(clientes.importe) as importe_nac_sexo;

STORE group_clientes INTO '/user/ubuntu/

Consumo_Clientes_Nac_Sexo' USING PigStorage('|');



clientes = LOAD '/user/ubuntu/Clientes_bbdd' USING PigStorage(',') AS (id_cliente:long,nombre:chararray,apellido:chararray,nif:chararray,telefono:long,nacionalidad:chararray,sexo:chararray,mes:int,anio:int,consumo:float,importe:float); clientes_anio_mes = GROUP clientes BY (anio,mes); group_clientes_2 = FOREACH clientes_anio_mes GENERATE group.anio, group.mes, AVG(clientes.consumo) as consumo_anio_sexo, AVG(clientes.importe) as importe_anio_sexo; STORE group_clientes_2 INTO '/user/ubuntu/Consumo_Clientes_Anio_Mes' USING PigStorage('|');



contratos = LOAD '/user/ubuntu/Contratos_bbdd' USING PigStorage(',') AS (id_contrato:long,id_cliente:long,producto:int,5tular:chararray,fecha:chararray,mes:int,anio:int,consumo:float,importe:float); detalle_consumo_fecha = FILTER contratos BY (producto==12 and anio==2013 and mes==12); STORE detalle_consumo_fecha INTO '/user/ubuntu/Detalle_Consumo_Fecha' USING PigStorage('|');



contratos = LOAD '/user/ubuntu/Contratos_bbdd' USING PigStorage(',') AS (id_contrato:long,id_cliente:long,producto:int,5tular:chararray,fecha:chararray,mes:int,anio:int,consumo:float,importe:float); contratos_producto = GROUP contratos BY (producto, anio); group_contratos = FOREACH contratos_producto GENERATE group.producto as producto, group.anio, SUM(contratos.consumo) as consumo_anio; consumo_contratos = GROUP group_contratos BY (producto); group_contratos_2 = FOREACH consumo_contratos GENERATE group, MAX(group_contratos.consumo_anio) as consumo_maximo; consumo_max = ORDER group_contratos_2 BY consumo_maximo; STORE consumo_max INTO '/user/ubuntu/Consumo_Contrato_Max' USING PigStorage('|');



clientes = LOAD '/user/ubuntu/Clientes_bbdd' USING PigStorage(',') AS (id_cliente:long,nombre:chararray,apellido:chararray,nif:chararray,telefono:long,nacionalidad:chararray,sexo:chararray,mes_cliente:int,anio_cliente:int,consumo_cliente:float,importe_cliente:float); contratos = LOAD '/user/ubuntu/Contratos_bbdd' USING PigStorage(',') AS (id_contrato:long,id_cliente:long,producto:int,5tular:chararray,fecha:chararray,mes_contrato:int,anio_contrato:int,consumo_contrato:float,importe_contrato:float); clientes_contratos = JOIN clientes BY (id_cliente,anio_cliente,mes_cliente), contratos BY (id_cliente,anio_contrato,mes_contrato) USING 'merge'; clientes_contratos_esp_fecha = FILTER clientes_contratos BY (nacionalidad == 'ESP' and producto == 1 and anio_contrato == 2014); group_clientes_contratos = GROUP clientes_contratos_esp_fecha BY (anio_cliente,mes_cliente,anio_contrato,mes_contrato); consumo_clientes_contratos = FOREACH group_clientes_contratos GENERATE group.anio_cliente, group.mes_cliente,group.anio_contrato,group.mes_contrato, SUM(clientes_contratos_esp_fecha.consumo_cliente) as consumo_cliente, SUM(clientes_contratos_esp_fecha.consumo_contrato) as consumo_contrato; consumo_clientes_contratos_output = FOREACH consumo_clientes_contratos GENERATE anio_cliente, mes_cliente, consumo_cliente, consumo_contrato; STORE consumo_clientes_contratos_output INTO '/user/ubuntu/Consumo_Clientes_Contrato_Pais_Producto_Fechas' USING PigStorage('|');



En este caso vamos a recolectar Logs a través de Flume para analizarlos con Hive.


Recolección de Logs y Análisis con Hive

•  Comenzaremos instalando Flume en nuestros nodos del Cluster: –  wget hSp://�p.cixug.es/apache/flume/1.5.2/apache-‐flume-‐1.5.2-‐bin.tar.gz

•  Posteriormente instalaremos Hive en nuestro nodo Maestro:

–  wget hSp://apache.rediris.es/hive/hive-‐0.14.0/apache-‐hive-‐0.14.0-‐bin.tar.gz

–  Configurar HIVE_HOME y el PATH en el fichero del profile. –  Configurar el fichero hive-‐site.xml:



<property> <name>javax.jdo.op5on.Connec5onURL</name> <value>jdbc:mysql://hadoop.master/metastore_db?createDatabaseIfNotExist=true</value> </property> <property> <name>javax.jdo.op5on.Connec5onUserName</name> <value>hive</value> </property> <property> <name>javax.jdo.op5on.Connec5onPassword</name> <value>password</value> </property> <property> <name>javax.jdo.op5on.Connec5onDriverName</name> <value>com.mysql.jdbc.Driver</value> </property> <property> <name>hive.metastore.uris</name> <value>thri�://hadoop.master:9083</value> </property>



–  Configuramos MySQL: •  Creamos la bases de datos para Hive:

mysql –u root –p CREATE USER 'hive'@'%' IDENTIFIED BY 'password'; GRANT all on *.* to 'hive'@'<EC2_IP_MASTER>' iden5fied by 'password'; flush privileges;

•  Copiamos el driver de MySql en las librerias de Hive: cp /usr/share/java/mysql.jar $HIVE_HOME/lib

–  Arrancaremos los servicios: $HIVE_HOME/bin/hive -‐-‐service metastore & $HIVE_HOME/bin/hiveserver2 &




Metastore remoto. Consiste en tener el servicio metastore en un proceso independiente que permite controlar de forma más segura el acceso al repositorio.


Metastore MySQL

Hive Cli

BI Tools

HiveServer2

•  Cuando ya tenemos descargado y configurado el sw podemos configurar los agentes de Flume: # Se�ng the source to exec tail file recolector.sources = exec recolector.conf recolector.sources.exec.type = exec recolector.sources.exec.command = tail -‐F /home/ubuntu/hadoop/logs/hadoop-‐ubuntu-‐namenode-‐ip-‐xxx-‐yyy-‐zzz-‐St.log recolector.sources.exec.interceptors = host recolector.sources.exec.interceptors.host.type = org.apache.flume.interceptor.HostInterceptor$Builder recolector.sources.exec.interceptors.host.useIP = true recolector.sources.exec.channels = memoryChannel # Se�ng the channel to memory recolector.channels = memoryChannel recolector.channels.memoryChannel.type = memory recolector.channels.memoryChannel.capacity = 1000 recolector.channels.memoryChannel.transac5onCapacity = 100 # Se�ng the sink to HDFS recolector.sinks = HDFS recolector.sinks.HDFS.type = hdfs recolector.sinks.HDFS.channel = memoryChannel recolector.sinks.HDFS.hdfs.path = hdfs://hadoop.master:9000/user/ubuntu/logs/host=%{host} recolector.sinks.HDFS.hdfs.fileType = DataStream recolector.sinks.HDFS.hdfs.writeFormat = Text



•  Una vez configurado lo arracaremos en cada nodo: $FLUME_HOME/bin/flume-‐ng agent -‐c conf -‐f recolector.conf -‐n recolector &

•  En HDFS podremos ir viendo como se van cargando los logs de los ficheros configurados: hdfs dfs -‐ls -‐R logs/*

•  Los pasos de instalación de Flume y arranque del agente se deberán realizar en todos aquellos nodos para los cuales queremos recolectar los Logs.



•  Ya podemos empezar a crear nuestra tabla de Hive para analizar los ficheros de Logs generados en HDFS: create database curso; CREATE EXTERNAL TABLE curso.logs_hadoop( date date, hour string, type string, class string, message string) PARTITIONED BY (host String) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe' WITH SERDEPROPERTIES ("input.regex" = "^(\\d{4}-‐\\d{2}-‐\\d{2})\\s(\\d{2}:\\d{2}:\\d{2},\\d{3})\\s(\\w+)\\s(\\w+.*:)\\s(\\w.*)") LOCATION '/user/ubuntu/logs';

ALTER TABLE logs.hadoop ADD PARTITION (host='<EC2_PRIVATE IP>');



•  Una vez que tenemos creada nuestra tabla podemos ejecutar nuestras consultas para analizar los logs: SELECT host, type, count(0) FROM logs_hadoop WHERE type IS NOT NULL GROUP BY host,type; SELECT host, date, count(0) FROM logs_hadoop WHERE type = 'WARN' GROUP BY date, host ORDER BY date;



SELECT hour, class, mensaje FROM logs_hadoop WHERE host = '172.31.17.45' AND type = 'WARN' AND date = '2015-‐03-‐06' AND class LIKE '%yarn%';

SELECT h1.host,h1.date,h1.class,h1.mensaje FROM logs_hadoop h1 join (SELECT MAX(DATE) as date FROM logs_hadoop WHERE type= 'WARN') h2 WHERE h1.date = h2.date AND h1.type = 'WARN';



En este úl5mo caso vamos a descargar Tweets con Flume para analizarlos con Hive.


Captura de Tweets y Análisis con Hive

•  Lo primero será crear unas claves para poder descargar los Tweets: –  hSps://apps.twiSer.com/

•  En este caso ya tenemos instalado el sw necesario: Flume y Hive, aunque será necesario generar unas librerias: –  sudo apt-‐get install git –  sudo apt-‐get install maven –  git clone git://github.com/cloudera/cdh-‐twiSer-‐example.git –  cd cdh-‐twiSer-‐example/flume-‐sources –  mvn install –  cp target/flume-‐sources-‐1.0-‐SNAPSHOT.jar $FLUME_HOME/lib –  cd ../hive-‐serdes –  mvn install –  cp target/hive-‐serdes-‐1.0-‐SNAPSHOT.jar /tmp/.

•  Posteriormente habrá que crear el fichero de configuración que descargará los tweets:



TwiSer.sources = twiSer TwiSer.channels = MemoryChannel twiSer.conf TwiSer.sinks = HDFS TwiSer.sources.twiSer.type = com.cloudera.flume.source.TwiSerSource TwiSer.sources.twiSer.consumerKey = <CONSUMER_KEY> TwiSer.sources.twiSer.consumerSecret = <CONSUMER_SECRET> TwiSer.sources.twiSer.accessToken = <ACCESS_TOKEN> TwiSer.sources.twiSer.accessTokenSecret = <ACCESS_TOKEN_SECRET> TwiSer.sources.twiSer.keywords = bigdata4success, hadoop, big data, bigdata, flume, sqoop, spark, mapreduce, hbase, mahout TwiSer.sources.twiSer.channels = MemoryChannel TwiSer.channels.MemoryChannel.type = memory TwiSer.channels.MemoryChannel.capacity = 10000 TwiSer.channels.MemoryChannel.transac5onCapacity = 100 TwiSer.sinks.HDFS.type = hdfs TwiSer.sinks.HDFS.hdfs.path = /user/ubuntu/tweets/%Y/%m/%d/ TwiSer.sinks.HDFS.hdfs.fileType = DataStream TwiSer.sinks.HDFS.hdfs.writeFormat = Text TwiSer.sinks.HDFS.hdfs.batchSize = 1000 TwiSer.sinks.HDFS.hdfs.rollSize = 0 TwiSer.sinks.HDFS.hdfs.rollCount = 10000 TwiSer.sinks.HDFS.channel = MemoryChannel



•  Ya sólo nos quedará copiar la librería de Flume y arrancar el agente: $FLUME_HOME/bin/flume-‐ng agent -‐c conf -‐f twiSer.conf -‐n TwiSer -‐Dflume.root.logger=DEBUG,console

•  Podremos ver los tweets que se van descargando en HDFS: hdfs dfs –ls –R tweSs

•  Vamos a examinar la estructura de un Tweet: –  Copiamos un Tweet en un fichero, por ejemplo, Tweet.json –  Lo examinamos:

cat Tweet.json| python -‐mjson.tool



•  Por úl5mo podemos crear la tabla de Hive que explotará los tweets descargados: use curso; add jar /tmp/hive-‐serdes-‐1.0-‐SNAPSHOT.jar;

CREATE EXTERNAL TABLE tweets ( id BIGINT, created_at STRING, text STRING, source STRING, favorited BOOLEAN, retweet_count INT, retweeted_status STRUCT< text:STRING, user:STRUCT<screen_name:STRING,name:STRING>>, en55es STRUCT< urls:ARRAY<STRUCT<expanded_url:STRING>>, user_men5ons:ARRAY<STRUCT<screen_name:STRING,name:STRING>>, hashtags:ARRAY<STRUCT<text:STRING>>>, user STRUCT< screen_name:STRING, name:STRING, friends_count:INT, followers_count:INT, statuses_count:INT, verified:BOOLEAN, utc_offset:INT, 5me_zone:STRING>, in_reply_to_screen_name STRING ) PARTITIONED BY (year String, month String, day String) ROW FORMAT SERDE 'com.cloudera.hive.serde.JSONSerDe' LOCATION '/user/ubuntu/tweets';



•  Modificamos la tabla creada para añadir las par5ciones correspondientes a los días para los cuales hemos descargado los tweets:

ALTER TABLE tweets ADD IF NOT EXISTS PARTITION (year = '2015', month = '03', day = '07') LOCATION '2015/03/07'; ALTER TABLE tweets ADD IF NOT EXISTS PARTITION (year = '2015', month = '03', day = '08') LOCATION '2015/03/08';



•  Ya podemos empezar a analizarlos: –  Antes de ejecutar alguna sentencia se deberá cargar la libreria en

cada sesión de Hive que abramos: add jar /tmp/hive-‐serdes-‐1.0-‐SNAPSHOT.jar;

–  Lanzamos nuestras queries:

use curso; SELECT text FROM tweets LIMIT 10; SELECT DISTINCT user.screen_name, user.followers_count FROM tweets ORDER BY followers_count;



SELECT CONCAT(YEAR,'-‐',MONTH, '-‐', DAY) as date, SUBSTR(created_at, 0, 3) as day_of_month, user.5me_zone, COUNT(*) AS count FROM tweets GROUP BY CONCAT(YEAR,'-‐',MONTH, '-‐', DAY ), SUBSTR(created_at, 0, 3), user.5me_zone ORDER BY count DESC; SELECT lower(hashtags.text), COUNT(*) AS count FROM tweets LATERAL VIEW EXPLODE(en55es.hashtags) adTable AS hashtags WHERE YEAR = '2015' AND MONTH = '03' AND DAY = '07' GROUP BY lower(hashtags.text) ORDER BY count DESC;



SELECT retweeted_status.user.screen_name, COUNT(*) as total FROM tweets GROUP BY retweeted_status.user.screen_name ORDER BY total DESC;

SELECT retweets.retweeted_user_screen_name, SUM(max_retweets) AS sum_retweets FROM (SELECT retweeted_status.user.screen_name as retweeted_user_screen_name, retweeted_status.text, MAX(retweet_count) as max_retweets FROM tweets GROUP BY retweeted_status.user.screen_name, retweeted_status.text) retweets GROUP BY retweets.retweeted_user_screen_name ORDER BY sum_retweets;



Inges5ón%y%Análisis%de%datos%con%Hadoop%... · 2016-01-25 · – Oracle% – MySQL% – Teradata...

Documents

Transcript of Inges5ón%y%Análisis%de%datos%con%Hadoop%... · 2016-01-25 · – Oracle% – MySQL% – Teradata...