U2ehsx26SzGNXZC9o8zs - Curso Data Analytics Con Hadoop. FcoJavierLahozSevilla v1.0 - NUEVA

Inges5n
y Anlisis de datos con Hadoop
Fco. Javier Lahoz Sevilla

Inges5n y Anlisis de datos con Hadoop
Parte 1. Inges5n de datos

Como cargar datos en Hadoop?
Recoleccin, agregacin y carga de eventos con Flume
Transferencia de bases de datos relacionales con Sqoop
Parte 2. Anlisis de datos

Como analizar datos en Hadoop?
Anlisis de grandes volmenes de datos a travs de Hive
Procesamiento de datos mediante un lenguaje de alto nivel con Pig
Parte 3. Casos prc5cos en AWS

Importacin de tablas relacionales y explotacin con Pig
Recoleccin y anlisis de Logs con Hive
Captura y anlisis de TweSs con Hive






Una vez que se ha diseado 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 informacin:
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, able y

escalable para la recoleccin, agregacin y
carga de grandes can5dades de datos.

Sqoop, est diseada para transferir datos de
manera eciente y escalable de bases de datos
relacionales a Hadoop.





Inges5n con Flume
Flume 5ene una arquitectura simple y exible basada en

el streaming de datos.
Es tolerante a fallos y escalable.
Se basa en una conguracin descentralizada basada en

chero planos.

Inges5n con Flume
Arquitectura.
La arquitectura de Flume est basada en agentes:

Agente

Source Sink

Datos Datos

Channel


Inges5n con Flume
Arquitectura.
Los agentes tambin se pueden conectar entre ellos:

Inges5n con Flume
Arquitectura.
Y tambin se pueden u5lizar para recolectar datos en capas:

Inges5n con Flume
Veamos un ejemplo ilustra5vo de la conguracin 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>


Inges5n con Flume

una agente:
agente.channels=micanal conguracin
agente.sinks=misink global





Inges5n con Flume

una agente:
agente.sinks=misink

agente.sources.misource.<propiedad 5po source> = <propiedad source> conguracin
agente.sources.misource.channels = micanal de la fuente




Inges5n con Flume

una agente:
agente.sinks=misink


agente.sinks.misink.<propiedat 5po sink> = <propiedad sink> conguracin
agente.sinks.misink.channels = micanal del de8no



Inges5n con Flume

una agente:
agente.sinks=misink



agente.channels. micanal.type = <5po channel> canal


Inges5n con Flume
Comenzaremos viendo algunos de los dis5ntos sources:

spooling directory: escanea los cheros de entrada en un
determinado directorio y lo enva como eventos.
Propiedades:
type = spooldir
channels = canal
spoolDir = directorio del FileSystem para el cual se escanearn los
cheros
leSux = sujo que se le pondr al chero escaneado
exec: ejecuta comandos del sistema opera5vo. Se suele u5lizar

para capturar cada nuevo registro de un chero con tail.
Propiedades:
type = exec
Channels = canal
command = comando a ejecutar


Inges5n 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 ume a travs de

Avro.
Propiedades:
type = avro
channels = canal
bind = host o IP donde escucha los eventos
port = puerto donde escucha los eventos

Inges5n con Flume
Se puede dar ms funcionalidad a los sources a travs de

Interceptores.

Los interceptores 5enen la capacidad de poder modicar los
eventos cuando se capturan o incluir ms informacin, por
ejemplo, el nombre del host, el 5mestamp o enviar valores
est5cos.
Adems de los interceptores por defecto que 5ene Flume

tambin es posible desarrollarlos a medida, por ejemplo, para
realizar transformaciones.


Inges5n 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.lePrex = nombre del chero que ser creado (por defecto, FlumeData)
avro: des5no para conectar agentes ume 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


Inges5n 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 = le_roll
channels = canal
sink.directory = el nombre del directorio donde se escribirn los eventos.


Inges5n con Flume
Por l5mo veremos los dis5ntos Channels:

memory: los eventos son almacenados en memoria.
Propiedades:
type = memory
capacity = mximo nmero de eventos cargados en el canal

le: los eventos se persis5rn en cheros.
Propiedades:
type = le
checkpointDir = directorio donde se almacenarn los checkpoint
dataDirs = directorios donde guardarn los cheros de log (serpados por
comas)


Inges5n con Flume
Ahora veamos un ejemplo real de conguracin de una

agente y como se ejecutara:
agente.sources=misource prueba_agente.conf
agente.sinks=misink

agente.sources.misource.type = spooldir
agente.sources.misource.spoolDir = /var/log/apache/
agente.sinks.misink.type = hdfs
agente.sinks.misink.hdfs.path = hdfs://hadoop.master:9000/tmp/
agente.channels. micanal.type = memory

Ejecucin ume-ng agent -n agente -c conf -f conf/prueba_agente.conf -
Dume.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 seran:
Oracle
MySQL
Teradata
DB2
.
Adems de puede exportar cheros de HDFS a bases de

datos relacionales.


Funcionamiento de Sqoop:
U5liza JDBC, por lo tanto, slo 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 informacin genera una clase
java para importar los datos que se ejecutar a travs de jobs
map-only (no se ejecutur fase Reduce).
Por defecto se ejecutarn cuatro mappers procesando cada uno
un cuarto de los datos a importar.
Todas las mquinas tendrn que tener permisos para acceder a
la base de datos.

Caracters5cas de Sqoop:
Sqoop puede importar una tabla o una esquema de base de
datos.
Tambin se pueden ltrar los datos de una tabla, por ejemplo,
para cargar incrementales basados en una fecha de alta o
modicacin.
Permite proyectar una tabla recuperando slo los campos
requeridos.
Sqoop puede importar los datos en un chero del HDFS, en una
tabla de Hive o de HBase.


Sqoop se ejecuta a travs 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

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





Importacin de base de dato y explotacin con Pig





Cuando ya tenemos datos cargados en nuestro Cluster

de Hadoop existen dis5ntas herramientas para analizar
los datos. Se podr u5lizar cada una de ellas segn los
conocimientos tcnicos:
Java
Scala
Python
SQL
Tambin existen herramientas OpenSource y comerciales

que, mediante workows, nos permiten analizar los datos.

Existen diversas tecnologas para analizar los datos

segn 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 travs 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 ujos 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 anlisis de

grandes conjuntos de datos que consiste
en un lenguaje de alto nivel para expresar
programas de anlisis de datos.





Anlisis 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 abstraccin para el acceso a los

datos por encima de Hadoop accediendo a los datos
del HDFS y procesndolos con MapReduce.
Se implementa en SQL (HiveQL)


Hive NO es una base de datos y usa los recursos de

Hadoop para almacenar y procesar.
Slo implementa un subconjunto del estandard SQL.
Actualmente no permirte Inserts, Updates y Deletes

ltrados.
No soporta transacciones ni ndices.
Tiene latencias grandes (por el uso de MapReduce).

Casos de uso:
Almacenamiento histrico ges5onado con par5ciones, por
ejemplo, con fecha (ao, mes, da, hora,)
Data Lakes: grandes almacenes de datos donde no toda la
informacin es suscep5ble de explotar. Se va
almacenando y se le dar estructura cuando sea necesario
analizarla.
Para repor5ng tradicional a travs de herramientas de BI.
Para anal5ca avanzada a travs de paquetes estads5cos,
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 cheros 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. Congurado por defecto en Hive donde el

repositorio es una base de datos Derby almacenada localmente en
el disco.

JVM

Driver
Metastore Derby



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

JVM

Driver Metastore

Postgre
JVM SQL

Driver Metastore


Metastore remoto. Consiste en tener el servicio metastore en un

proceso independiente que permite controlar de forma ms
segura el acceso al repositorio.

JVM

Driver

Metastore Postgre
JVM SQL

Driver


Conguracin de Hive:
Similar a Hadoop, Hive 5ene varios cheros de
conguracin:
hive-env.sh, para la conguracin del entorno y la localizacin de

Hadoop, por ejemplo.
hive-site.xml, donde se parametrizan las propiedades de hive,

como por ejemplo, el 5po de metastore a u5lizar, seguridad,
memora asignada a los jobs, auten5cacin, cheros de logs, entre
otros posibles parmetros. Por defecto se cargar la conguracin
del chero 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, >)

Ges5n 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_eld1> type,<db_eld2> 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 ', ';

Sera el momento de cargar datos:
Mediante un LOAD desde un chero local o de HDFS:
LOAD DATA (LOCAL) INPATH 'test.csv'

(OVERWRITE) INTO TABLE test_table;
O copiando un chero del hdfs al path de Hive:
hive>dfs put test.csv /user/hive/warehouse/test.db/

test_table/.

Otra opcin 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';

Tambin se pueden crear tablas externas con una

sintaxis similar a la anterior pero indicando la
ubicacin del chero:

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 organizacin de los datos y la op5mizacin en la
explotacin 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);
month=02,day=19);
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 estn estructurados pero

tambin se pueden recuperar datos no estructurados,
como json (caso de tweets) o semi estruturados, por
ejemplo, los logs de una aplicacin. Para estos casos no se
puede u5lizar un separador ,.
Con SerDe (Serializacin Deserializacin) se pueden denir

expresiones regulares (regex) para dar estructura a los
datos.
Para denir la expresin regular que vamos a ver a

con5nuacin 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 Deni5on Func5ons).

Las UDFs son libreras que se pueden registrar en Hive para
implementar, a travs de Java, funciones avanzadas, como
por ejemplo, clculos aritm5cos complejos o tratamiento
avanzada de texto.

Op5mizacin de tablas con Hive:

Al igual que las bases de datos relacionales como Oracle con
Hive tambin se puede obtener el explain plain para poder
op5mizar las consultas. Slo es necesario aadir 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




Importacin de base de datos y explotacin con Pig

Procesamiento de datos con Pig
Pig es una plataforma para el anlisis de grandes

conjuntos de datos que consiste en un lenguaje de
alto nivel para expresar programas de anlisis de
datos.
En Pig se procesa la informacin como un ujo 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
Pig es una capa que est Scrip5ng
por encima de Hadoop. Los

ujos de datos se
procesarn con MapReduce
MapReduce
leyendo y escribiendo en

HDFS u otras fuentes
(MongoDB, Cassandra,
HBase) HDFS

Conguracin de Pig:
Al igual que vimos para Hive en Pig tambin se pueden
congurar dis5ntas propiedades en el chero,
pig.proper5es, como por ejemplo:
Ges5n de la memoria
Nivel de Log
Perl para UDFs
Tipo de ejecucin por defecto
Librerias adicionales
Directorio temporal para cachear
Opciones de ejecucin

Ejecucin de Pig:
Pig se puede ejecutar de las siguientes formas:
Molo local, ejecucin en una instancia local.
> pig -x local
Modo MapReduce (congurado por defecto) usar los recursos de
hadoop para el procesamiento de las tareas.
> pig (pig -x mapreduce)
Modo Tez, para ejecucin de jobs con menor latencia.
> pig -x tez

Tambin existen diversas modos de ejecucin:
Interac5vo
Batch: pig <script>.pig

Flujo de ejecucin con Pig:

Operaciones Relacionales

Load Transform Store
Datos Datos
Data Data Data



Datos Datos
Data Data Data
A = load test.csv using PigStorage(,);




Datos Datos
Data Data Data

B = foreach A generate $0 as id;




Datos Datos
Data Data Data

B = foreach A generate $0 as id;
store B into result.csv


Tipos de datos:
Tipos simples:
int
Long
oat
double
chararray
bytearray
boolean
date5me

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

Tipos de Operadores:
Funciones de evaluacin: Funciones de Strings:
Count, Sum IndexOf
Avg, Max, Min Lower, Upper
Concat Replace
isEmpty Substring
Tokenize Trim
Funciones matem5cas: Funciones para fechas:

Abs, Cos, Sin, Exp, Log GetYear,GetMonth,
Floor, Ceil, Round 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, funcin 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] | eld_alias [ASC|DESC] [,
eld_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, funcin 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 Deni5on Func5ons).

Op5mizacin de ujos con Pig:
Al igual que en Hive tambin se puede obtener el explain
para el Debug de una operacin relacional indicando Explain
con la operacin relizada
Ejemplo:
Explain B;









Importacin de datos y explotacin con Pig

En este primer caso vamos a importar unas tablas
con Sqoop para posteriormente procesarlas 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 conguraremos la IP privada de la instancia
de EC2 en el chero de conguracin
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 modicar el PATH en el prole del usuario.
Copiar el driver de conexin con MySql en las librerias de Sqoop
cp /usr/share/java/mysql.jar $SQOOP_HOME/lib


Seguiremos con la instalacin de Pig:
wget hSp://apache.rediris.es/pig/pig-0.14.0/pig-0.14.0.tar.gz
Crear PIG_HOME y modicar el PATH en el prole del usuario.
Modicar la conguracin de Hadoop para incluir el

historyserver aadiendo en el chero 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 mquinas 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;


Generaremos los cheros que vamos a cargar a travs del generador de datos,
GeneradorDatosCurso.java

Con5nuaremos creando las tablas en la BBDD y cargamos los cheros.
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 oat,
importe oat,
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
cheros.
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 oat,
importe oat,
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 importacin 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 unicar los cheros 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 analizarn 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:oat, importe:oat);

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:charar
ray,telefono:long,nacionalidad:chararray,sexo:chararray,mes:in
t,anio:int,consumo:oat,importe:oat);

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:char
array,fecha:chararray,mes:int,anio:int,consumo:oat,imp
orte:oat);

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,m
es:int,anio:int,consumo:oat,importe:oat);

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,se
xo:chararray,mes_cliente:int,anio_cliente:int,consumo_cliente:oat,importe_cliente:oat);

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_con
trato:int,consumo_contrato:oat,importe_contrato:oat);

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('|');






Recoleccin de Logs y Anlisis con Hive

En este caso vamos a recolectar Logs a travs de
Flume para analizarlos con Hive.


Comenzaremos instalando Flume en nuestros nodos del

Cluster:
wget
hSp://p.cixug.es/apache/ume/1.5.2/apache-ume-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
Congurar HIVE_HOME y el PATH en el chero del prole.
Congurar el chero 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>


Conguramos 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>' iden5ed by
'password';
ush 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 ms segura el acceso al repositorio.

BI Tools

HiveServer2 Metastore MySQL
Hive Cli

Cuando ya tenemos descargado y congurado el sw podemos
congurar los agentes de Flume:
# Seng the source to exec tail le
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.ume.interceptor.HostInterceptor$Builder
recolector.sources.exec.interceptors.host.useIP = true
recolector.sources.exec.channels = memoryChannel
# Seng the channel to memory
recolector.channels = memoryChannel
recolector.channels.memoryChannel.type = memory
recolector.channels.memoryChannel.capacity = 1000
recolector.channels.memoryChannel.transac5onCapacity = 100
# Seng 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.leType = DataStream
recolector.sinks.HDFS.hdfs.writeFormat = Text


Una vez congurado lo arracaremos en cada nodo:

$FLUME_HOME/bin/ume-ng agent -c conf -f
recolector.conf -n recolector &

En HDFS podremos ir viendo como se van cargando los
logs de los cheros congurados:
hdfs dfs -ls -R logs/*

Los pasos de instalacin de Flume y arranque del agente
se debern realizar en todos aquellos nodos para los
cuales queremos recolectar los Logs.

Ya podemos empezar a crear nuestra tabla de Hive para
analizar los cheros 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';





Captura de Tweets y Anlisis con Hive

En este l5mo caso vamos a descargar Tweets con
Flume para analizarlos 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/ume-sources
mvn install
cp target/ume-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 chero de conguracin que
descargar los tweets:

TwiSer.sources = twiSer
TwiSer.channels = MemoryChannel twiSer.conf
TwiSer.sinks = HDFS

TwiSer.sources.twiSer.type = com.cloudera.ume.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, ume, 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.leType = 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 slo nos quedar copiar la librera de Flume y arrancar el

agente:
$FLUME_HOME/bin/ume-ng agent -c conf -f twiSer.conf -n TwiSer -
Dume.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 chero, 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,
veried:BOOLEAN,
utc_oset: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';


Modicamos la tabla creada para aadir las par5ciones

correspondientes a los das 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 sesin 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;



U2ehsx26SzGNXZC9o8zs - Curso Data Analytics Con Hadoop. FcoJavierLahozSevilla v1.0 - NUEVA

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

U2ehsx26SzGNXZC9o8zs - Curso Data Analytics Con Hadoop. FcoJavierLahozSevilla v1.0 - NUEVA

Cargado por

Copyright:

Formatos disponibles

Inges5n

y Anlisis de datos con Hadoop

Fco. Javier Lahoz Sevilla

Parte 1. Inges5n de datos

Parte 2. Anlisis de datos

Parte 3. Casos prc5cos en AWS

Fco. Javier Lahoz Sevilla

Parte 1. Inges5n de datos

Parte 2. Anlisis de datos

Parte 3. Casos prc5cos en AWS

Fco. Javier Lahoz Sevilla

Existen varias herramientas o productos para

Fco. Javier Lahoz Sevilla

Se pueden recolectar datos de dis5nta variedad:

Fco. Javier Lahoz Sevilla

Para poder capturar este variedad de datos

Flume, es una herramienta distribuida, able y

Fco. Javier Lahoz Sevilla

Parte 1. Inges5n de datos

Parte 2. Anlisis de datos

Parte 3. Casos prc5cos en AWS

Fco. Javier Lahoz Sevilla

Flume 5ene una arquitectura simple y exible basada en

Es tolerante a fallos y escalable.

Se basa en una conguracin descentralizada basada en

Fco. Javier Lahoz Sevilla

Veamos un ejemplo ilustra5vo de la conguracin de

Veamos un ejemplo ilustra5vo de la conguracin de

Veamos un ejemplo ilustra5vo de la conguracin de

Veamos un ejemplo ilustra5vo de la conguracin de

Veamos un ejemplo ilustra5vo de la conguracin de

Comenzaremos viendo algunos de los dis5ntos sources:

exec: ejecuta comandos del sistema opera5vo. Se suele u5lizar

avro: se u5liza para comunicar agentes de ume a travs de

Fco. Javier Lahoz Sevilla

Se puede dar ms funcionalidad a los sources a travs de

Adems de los interceptores por defecto que 5ene Flume

Fco. Javier Lahoz Sevilla

Seguiremos viendo algunos Sinks:

Fill Roll: para escribir los eventos en el File System.

Fco. Javier Lahoz Sevilla

Por l5mo veremos los dis5ntos Channels:

Ahora veamos un ejemplo real de conguracin de una

Parte 1. Inges5n de datos

Parte 2. Anlisis de datos

Parte 3. Casos prc5cos en AWS

Fco. Javier Lahoz Sevilla

Con Sqoop se puede importar datos de bases de datos

Adems de puede exportar cheros de HDFS a bases de

Fco. Javier Lahoz Sevilla

Sqoop se ejecuta a travs de lineas de comandos:

sqoop import --connect jdbc:mysql://<db_ip>/<db_name> --

sqoop import --column a,b,c,d --where a>100 and b <10 --

sqoop import --query 'SELECT a.*, b.* FROM a JOIN b on (a.id

Parte 1. Inges5n de datos

Parte 2. Anlisis de datos

Parte 3. Casos prc5cos en AWS

Fco. Javier Lahoz Sevilla

Parte 1. Inges5n de datos

Parte 2. Anlisis de datos

Parte 3. Casos prc5cos en AWS

Fco. Javier Lahoz Sevilla

Cuando ya tenemos datos cargados en nuestro Cluster

sqoop import --query 'SELECT a., b. FROM a JOIN b on (a.id