Monta una Infraestructura para Big Data en tu Empresa

  • Published on
    18-Jul-2015

  • View
    484

  • Download
    0

Embed Size (px)

Transcript

  • Taller: Monta una infraestructura Big Data para

    tu Empresa

    Urko Zurutuza Dpto. Electrnica e Informtica

    Mondragon Goi Eskola Politeknikoa JMA Mondragon Unibertsitatea

  • Agenda

    Da 1: Introduccin al Big Data Da 2: Instalacin de un cluster Cloudera Da 3: Ejercicios sobre Cloudera

  • ndice

    1. Ejemplo de MapReduce 2. Creando y editando una base de datos HBase 3. Ingerir datos estructurados con Apache sqoop 4. Formas de montar infraestructuras Big Data 5. Configuracin del laboratorio

  • Consideraciones previas

    Cloudera Quick Start: http://www.cloudera.com/content/cloudera/en/documentation/

    core/latest/topics/cloudera_quickstart_vm.html

    Direccin Cloudera Manager: http://193.146.78.55:7180 Direccin Hue: http://193.146.78.55:8888 Algunos links no son relativos (y erroneamente llevarn

    a quickstart.cloudera)

  • Consideraciones previas

    Cuenta (con privilegios sudo): username: cloudera password: cloudera

    La contrasea de root de MySQL es la misma, al igual que Hue y Cloudera Manager

  • Consideraciones previas

    Atencin: Cada vez que subamos, modifiquemos o creemos nuevos

    directorios o ficheros utilizaremos la siguiente nomenclatura: _user _user.

    Ejemplo: mkdir wordcount_classes_user00 javac -cp -d wordcount_classes WordCount.java

  • Consideraciones previas

    Atencin: Vamos a crear unas carpetas necesarias en HDFS: $ hadoop fs mkdir /user/cloudera/

  • Consideraciones previas

  • Ejemplo MapReduce

  • Procesamiento en batch: MapReduce

    Marco para escribir aplicaciones que procesan enormes cantidades de datos de forma paralela en grandes clusters formados por hardware comn.

    MapReduce job Divide el conjunto de datos de entrada en pedazos (chunks) que son

    procesados por tareas map de forma paralela. Ordena las salidas de los maps, que son entrada a las tareas

    reduce. Opera sobre pares clave-valor. No necesariamente en Java.

  • Procesamiento en batch: MapReduce

    , 4, 2, 4, 3

    , 4

    , 2

    , 4

    , 3

    Split MapShufe

    &Sort

    Reduce

    Masterass

    ignsassigns

  • Procesamiento en batch: MapReduce

    Ejemplo: $ bin/hadoop dfs -cat /usr/joe/wordcount/input/file01 Hello World Bye World $ bin/hadoop dfs -cat /usr/joe/wordcount/input/file02 Hello Hadoop Goodbye Hadoop

  • Procesamiento en batch: MapReduce

    Mapper: procesa cada lnea (cada lnea un map) Divide en tokens separados por espacios (palabras) Emite un conjunto de claves-valor, en modo Map 1:

    < Hello, 1> < World, 1> < Bye, 1> < World, 1>

    Map 2: < Hello, 1> < Hadoop, 1> < Goodbye, 1> < Hadoop, 1>

  • Procesamiento en batch: MapReduce

    Combiner: Cada map se ordena y genera agregados locales: Salida del primer Map:

    < Bye, 1> < Hello, 1> < World, 2>

    Salida del segundo Map: < Goodbye, 1> < Hadoop, 2> < Hello, 1>

  • Procesamiento en batch: MapReduce

    Reducer: Suma los valores (ocurrencias de cada clave):

    < Bye, 1> < Goodbye, 1> < Hadoop, 2> < Hello, 2> < World, 2>

  • Ejercicio

    WordCount Documento ejercicios.doc

  • Ejemplo HBase

  • HBase

    Qu es Hbase? En Hbase los datos se almacenan en tablas, las cuales tienen filas

    y columnas pero mejor verlo como un mapa u objeto multidimensional

    Una tabla de Hbase contiene multiples filas. Una fila de datos tiene una clave ordenable y un nmero arbitrario

    de columnas. La tabla se almacena de forma dispersa, de modo que las filas de una misma tabla pueden tener columnas tan variadas como se quiera.

  • HBase

    Map: filas de datos

    { "zzzzz" : "woot", "xyz" : "hello", "aaaab" : "world", "1" : "x", "aaaaa" : "y" }

  • HBase

    Sorted Map: filas ordenadas por la clave

    { "1" : "x", "aaaaa" : "y", "aaaab" : "world", "xyz" : "hello", "zzzzz" : "woot" }

  • HBase

    Multidimensional: familias de columnas por cada fila { "1" : { "A" : "x", "B" : "z" }, "aaaaa" : { "A" : "y", "B" : "w" }, "aaaab" : { "A" : "world", "B" : "ocean" }, "xyz" : { "A" : "hello", "B" : "there" }, "zzzzz" : { "A" : "woot", "B" : "1337" } }

  • HBase

    Multidimensional: una familia de columnas puede tener varias columnas, identificadas por una etiqueta o qualifier

    { // ... "aaaaa" : { "A" : { "foo" : "y", "bar" : "d" }, "B" : { "" : "w" } }, "aaaab" : { "A" : { "foo" : "world", "bar" : "domination" }, "B" : { "" : "ocean" } }, // ... }

  • HBase

    Multidimensional: timestamp { // ... "aaaaa" : { "A" : { "foo" : { 15 : "y", 4 : "m" }, "bar" : { 15 : "d", } }, "B" : { "" : { 6 : "w" 3 : "o" 1 : "w" } } }, // ... }

  • Ejemplo con HBase

  • Ejercicio: Ingerir datos estructurados

  • Un paseo por la potencia de Big Data

    Imaginemos que somos el Data Specialist de una corporacin

    El anlisis de los datos debe responder a preguntas concretas

  • Definir una pregunta de Negocio

    Sin una pregunta bien definida: No sabremos como modelar los datos Qu estructuras de datos aplicar Qu conjuntos de datos deberemos obtener Qu herramientas necesitaremos

  • Ejercicio: Ingerir datos estructurados

    Pregunta de Negocio: Qu productos les gusta comprar a nuestros clientes?

    Esta informacin se guarda por lo general en una base de datos Transaccional, la cual nos dir qu clientes compran y quienes no cada producto.

    Necesitamos ingerir los datos de una BBDD en HDFS

  • sqoop

  • Ejercicio 1: Ingerir datos estructurados

    Sqoop nos permite cargar los datos de MySQL en HDFS, preservando la estructura de las tablas.

    Con unos parmetros extra, podremos cargarlos en un formato (avro) que podr luego ser utilizado por Impala

  • Ejercicio 1: Ingerir datos estructurados: sqoop

    tablas tablas Ficheros

    distribuidos

    BBDD Relacional

    BBDD Relacional HDFS

    Tratamiento

    (Map-Reduce) (Map-Reduce)

    (Map-Reduce)

  • Ejercicio1 : Ingerir datos estructurados

    (Mirar Documento) [root@quickstart.cloudera ~] sqoop import-all-tables \ -- num-mappers 1 \ --connect jdbc:mysql://quickstart.cloudera:3306/retail_db \ --username=retail_dba \ --password=cloudera \ --compression-codec=snappy \ --as-avrodatafile \ --warehouse-dir=/user/hive/warehouse/userXX

  • Ejercicio1 : Ingerir datos estructurados

  • Ejercicio1 : Ingerir datos estructurados

    Dos herramientas para hacer consultas SQL en CDH: Hive

    Traduce las consultas SQL a trabajos MapReduce. Bueno para trabajos en lote grandes, aplicando transformaciones

    de forma flexible. Impala

    Significativamente ms rpido y preparado para tener baja latencia para consultas interectivas y exploracin de datos.

    Ambos comparten los metadatos sobre las tablas

  • Ejercicio1 : Ingerir datos estructurados

    Ejemplo en HIVE: [cloudera@quickstart ~]$ hive CREATE EXTERNAL TABLE categories ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.avro.AvroSerDe' STORED AS INPUTFORMAT 'org.apache.hadoop.hive.ql.io.avro.AvroContainerInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.avro.AvroContainerOutputFormat' LOCATION 'hdfs:///user/hive/warehouse/categories' TBLPROPERTIES ('avro.schema.url'='hdfs://quickstart.cloudera/user/urko/sqoop_import_categories.avsc');

    categories, customers, departments, orders, order_items, products show tables; exit;

  • Ejercicio 2

  • Ejercicio2 : Consultar datos estructurados

    Hemos transferido datos estructurados de una base de datos relacional a HDFS

    Lo hemos transformado en formato Avro Hemos creado tablas HIVE, preparadas para ser

    consultadas mediante Impala o consultas por lotes de HIVE.

    Vamos a consultarlos!

  • Ejercicio2 : Consultar datos estructurados

  • Ejercicio2 : Consultar datos estructurados

  • Ejercicio2 : Consultar datos estructurados

  • Ejercicio2 : Consultar datos estructurados

  • Ejercicio2 : Consultar datos estructurados

  • Ejercicio 3

  • Ejercicio 3: El valor del Big Data

    Hasta ahora, el resultado no es nuevo: SQL! Pregunta de negocio: son los productos ms vistos los

    ms vendidos? Devemos correlacionar datos estructurados con otros no

    estructurados: Usando Web logs, podremos ver los productos ms vistos

    Para ingerir flujos de clicks: Flume

  • Ejercicio 3: El valor del Big Data

    Flume: un framework de tiempo real y escalable para encaminar, filtrar, agregar, y realizar pequeas operaciones sobre datos

    Para este ejercicio, ya tenemos recopilados un conjunto de datos de acceso web en /opt/examples/log_data/access.log.2

  • Ejercicio 3: El valor del Big Data

  • Ejercicio 3: El valor del Big Data

    Cargar los datos de log a HDFS: sudo -u hdfs hadoop fs -mkdir /user/hive/warehouse/original_access_logs sudo -u hdfs hadoop fs -copyFromLocal /opt/examples/log_files/access.log.2 /user/hive/warehouse/original_access_logs hadoop fs -ls /user/hive/warehouse/original_access_logs

    Crear una tabla en Hive, y consultarla mediante Impala o Hive

  • Ejercicio 3: El valor del Big Data

    CREATE EXTERNAL TABLE intermediate_access_logs_nombre ( ip STRING, date STRING, method STRING, url STRING, http_version STRING, code1 STRING, code2 STRING, dash STRING, user_agent STRING) ROW FORMAT SERDE 'org.apache.hadoop.hive.contrib.serde2.RegexSerDe' WITH SERDEPROPERTIES ( "input.regex" = "([^ ]*) - - \\[([^\\]]*)\\] \"([^\ ]*) ([^\ ]*) ([^\ ]*)\" (\\d*) (\\d*) \"([^\"]*)\" \"([^\"]*)\"", "output.format.string" = "%1$s %2$s %3$s %4$s %5$s %6$s %7$s %8$s %9$s" ) LOCATION '/user/hive/warehouse/original_access_logs';

  • Ejercicio 3: El valor del Big Data

    CREATE EXTERNAL TABLE tokenized_access_logs_nombre ( ip STRING, date STRING, method STRING, url STRING, http_version STRING, code1 STRING, code2 STRING, dash STRING, user_agent STRING) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LOCATION '/user/hive/warehouse/tokenized_access_logs'; ADD JAR /usr/lib/hive/lib/hive-contrib.jar; INSERT OVERWRITE TABLE tokenized_access_logs SELECT * FROM intermediate_access_logs_nombre; exit;

  • Ejercicio 3: El valor del Big Data

  • Ejercicio 3: El valor del Big Data

  • Ejercicio 3: El valor del Big Data

  • Ejercicio 3: El valor del Big Data

  • Ejercicio 3: El valor del Big Data

  • Ejercicio 3: El valor del Big Data

    Uno de los productos ms vistos no est entre los ms comprados!!

  • Ejercicio 3: El valor del Big Data

    La correlacin entre ambos datos permiti detectar un error en el precio mostrado para el producto Adidas Kids RG III Mid Football Cleat. Una vez corregido, las ventas del producto empezaron a crecer rpidamente ;)

  • Ejercicio 4

  • Ejercicio 4: Advanced Analytics

    Pregunta de negocio: Qu productos se suelen comprar de forma conjunta?

    La respuesta podra ayudar a: Optimizar campaas de marketing, posicionando productos de

    forma conjunta Podran utilizarlo para mejorar ventas de productos menos vistos

    Una herramienta que permite realizar anlisis rpidos sobre relaciones de objetos es Apache Spark

  • Ejercicio 4: Advanced Analytics

    Apache Spark

    spark-shell --jars /usr/lib/avro/avro-mapred.jar \ --conf spark.serializer=org.apache.spark.serializer.KryoSerializer

  • Ejercicio 4: Advanced Analytics

    // First we're going to import the classes we need and open some of the files // we imported from our relational database into Hadoop with Sqoop import org.apache.avro.generic.GenericRecord import org.apache.avro.mapred.{AvroInputFormat, AvroWrapper} import org.apache.hadoop.io.NullWritable val warehouse = "hdfs://quickstart.cloudera/user/hive/warehouse/" val order_items_path = warehouse + "order_items" val order_items = sc.hadoopFile[AvroWrapper[GenericRecord], NullWritable, AvroInputFormat[GenericRecord]](order_items_path) val products_path = warehouse + "products" val products = sc.hadoopFile[AvroWrapper[GenericRecord], NullWritable, AvroInputFormat[GenericRecord]](products_path)

  • Ejercicio 4: Advanced Analytics

    // First we're going to import the classes we need and open some of the files // we imported from our relational database into Hadoop with Sqoop import org.apache.avro.generic.GenericRecord import org.apache.avro.mapred.{AvroInputFormat, AvroWrapper} import org.apache.hadoop.io.NullWritable val warehouse = "hdfs://quickstart.cloudera/user/hive/warehouse/" val order_items_path = warehouse + "order_items" val order_items = sc.hadoopFile[AvroWrapper[GenericRecord], NullWritable, AvroInputFormat[GenericRecord]](order_items_path) val products_path = warehouse + "products" val products = sc.hadoopFile[AvroWrapper[GenericRecord], NullWritable, AvroInputFormat[GenericRecord]](products_path)

  • Ejercicio 4: Advanced Analytics

    // Next, we extract the fields from order_items and products that we care about // and get a list of every product, its name and quantity, grouped by order val orders = order_items.map { x => ( x._1.datum.get("order_item_product_id"), (x._1.datum.get("order_item_order_id"), x._1.datum.get("order_item_quantity"))) }.join( products.map { x => ( x._1.datum.get("product_id"), (x._1.datum.get("product_name"))) } ).map(x => ( scala.Int.unbox(x._2._1._1), // order_id ( scala.Int.unbox(x._2._1._2), // quantity x._2._2.toString // product_name ) )).groupByKey()

  • Ejercicio 4: Advanced Analytics

    // Finally, we tally how many times each combination of products appears // together in an order, and print the 10 most common combinations. val cooccurrences = orders.map(order => ( order._1, order._2.toList.combinations(2).map(order_pair => ( if (order_pair(0)._2 < order_pair(1)._2) (order_pair(0)._2, order_pair(1)._2) else (order_pair(1)._2, order_pair(0)._2), order_pair(0)._1 * order_pair(1)._1 ) ) ) ) val combos = cooccurrences.flatMap(x => x._2).reduceByKey((a, b) => a + b) val mostCommon = combos.map(x => (x._2, x._1)).sortByKey(false).take(10) println(mostCommon.deep.mkString("\n"))

  • Ejercicio 4: Advanced Analytics

  • Ejercicio 5

  • Ejercicio 5: buscando en un mar de datos

    Los logs pueden ser una fuente imprescindible de informacin

    Vamos a ser capaces de explorar de forma interactiva eventos de Log Web, indexando los datos, y haciendo que puedan ser buscados

    Vamos a extende Apache Flume anterior, de modo que ademas de ingerir logs, enviar los eventos a Apache Solr para su indesacin en tiempo real

  • Ejercicio 5: buscando en un mar de datos

    Flume

    Solr Organiza los datos de la misma manera que una BBDD SQL.

    Dada registro se llama document, y contiene campos definidos en un esquema Un conjunto de documentos forman una coleccin.

    Es menos estricto en cuanto a la estructura: Campos opcionales Flexibilidad en las consultas de texto

  • Ejercicio 5: buscando en un mar de datos

    Crear el ndice de bsqueda: solrctl --zk quickstart.cloudera:2181/solr instancedir --generate solr_configs Generar los ficheros de configuracin:

  • Ejercicio 5: buscando en un mar de datos

    Cargar la configuracion cd /opt/examples/flume solrctl --zk quickstart.cloudera:2181/solr instancedir --create live_logs ./solr_configs

    Crear la coleccin solrctl --zk quickstart.cloudera:2181/solr collection --create live_logs -s 1

  • Ejercicio 5: buscando en un mar de dato...

Recommended

View more >