bigdata y mapreduce

Big Data y MapReduce

Tomás Fernández Pena

Máster en Computación de Altas Prestaciones

Universidade de Santiago de Compostela

Computación en Sistemas Distribuidos

Material bajo licencia Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)citius.usc.es

http://creativecommons.org/licenses/by-sa/4.0/

Big Data Introducción a MapReduce Ejemplos de uso Ejecución Optimizaciones Implementaciones Conclusiones

Índice

1 Big Data

2 Introducción a MapReduce

3 Ejemplos de uso

4 Ejecución

5 Optimizaciones

6 Implementaciones

7 Conclusiones

Big Data y MapReduce, CSD


¿Qué es Big Data?

Wikipedia

In information technology, big data is a collection of data sets so large

and complex that it becomes difficult to process using on-hand database

management tools or traditional data processing applications. The

challenges include capture, curation, storage, search, sharing, analysis,

and visualization.

Big Data y MapReduce, CSD 1/38

http://en.wikipedia.org/wiki/Big_Data


Características del Big Data

Las 5 Vs del BigData

Volume enorme cantidad de datos generados

Velocity rapidez con la que se generan y mueven esos datos

Variety datos de múltiples tipos, estructurados y

no-estructurados: texto, datos de sensores, audio, vídeo,

click streams, ficheros de log, etc.

Veracity datos correctos o incorrectos

Value capacidad de extraer valor de los datos



Aluvión de datos

El mundo está creando más bits que nunca: en 2013, se había unos 4,4

Zettabytes (4, 4× 1021), y se estiman unos 44 ZB en 2020

La

cantidad de datos se dobla cada dos años



Fuentes de datos

Origen de los datos:

Redes sociales

Redes de sensores

Datos de GPS

Datos científicos

. . .



Data gap



Retos tecnológicos (I)

Búsqueda y refinamiento (Lucene, Solr, Elasticsearch, OpenRefine,

ScraperWiki, BloomReach)

Serialización (JSON, BSON, Apache Thrift, Apache Avro, Google

Protocol Buffers)

Sistemas de almacenamiento (HDFS, GFS, Lustre, Amazon S3)

Servidores (Amazon EC2, Google Cloud Platform, HP Cloud, Heroku,

AWS Elastic Beanstalk, OpenShift, Azure, pivotal, Whirr, Ambari)

Procesamiento (Hadoop, Hive, Pig, Spark, Tez, Cascading, Azkaban,

Oozie, mrjob, Twister, Apache Flume, Storm, S4, Falcon, Cloudera,

MapR, Hortonworks, Platfora)


http://en.wikipedia.org/wiki/Lucene

http://lucene.apache.org/solr/

http://www.elasticsearch.org/

http://openrefine.org/

https://scraperwiki.com/

http://www.bloomreach.com/

http://www.json.org/

http://bsonspec.org/

http://thrift.apache.org/

http://avro.apache.org/

http://code.google.com/p/protobuf/

http://code.google.com/p/protobuf/

http://hadoop.apache.org/docs/current/hadoop-project-dist/hadoop-hdfs/HdfsUserGuide.html

http://research.google.com/archive/gfs.html

http://lustre.opensfs.org/

http://aws.amazon.com/es/s3/

http://aws.amazon.com/es/ec2/

https://cloud.google.com/

https://www.hpcloud.com/

http://www.heroku.com/

http://aws.amazon.com/es/elasticbeanstalk/

https://openshift.redhat.com/app/

http://azure.microsoft.com/

http://www.pivotal.io/

http://whirr.apache.org/

http://incubator.apache.org/ambari/

http://hadoop.apache.org/

http://hive.apache.org/

http://pig.apache.org/

https://spark.apache.org/

http://tez.apache.org/

http://www.cascading.org/

http://data.linkedin.com/opensource/azkaban

http://oozie.apache.org/

http://pythonhosted.org/mrjob/

http://www.iterativemapreduce.org/

http://flume.apache.org/

http://storm-project.net/

http://incubator.apache.org/s4/

http://falcon.incubator.apache.org/

http://www.cloudera.com

http://www.mapr.com/

http://hortonworks.com/

http://www.platfora.com/


Retos tecnológicos (II)

Bases de datos (HBase, Cassandra, Accumulo, MongoDB, CouchDB,

Hypertable, Riak, Amazon DynamoDB, Google BigTable, Sqoop)

Análisis (R, Yahoo Pipes, IBM BigSheets, Greenplum, Datameer,

Continuuity, WibiData)

Lenguaje natural (Natural Language Toolkit, Apache OpenNLP,

Boilerpipe, Calais)

Machine learning (aprendizaje automático) (Weka, Apache Mahout,

scikit-learn, Skytree)

Visualización (R, Graphviz, Processing, Protovis, Tableau, Google

Fusion Tables)


http://hbase.apache.org/

http://cassandra.apache.org/

http://accumulo.apache.org/

http://www.mongodb.org/

http://couchdb.apache.org/

http://hypertable.org/

http://docs.basho.com/riak/latest/

http://aws.amazon.com/es/dynamodb/

http://research.google.com/archive/bigtable.html

http://sqoop.apache.org/

http://www.r-project.org/

http://pipes.yahoo.com/pipes/

http://www-01.ibm.com/software/ebusiness/jstart/bigsheets/

http://gopivotal.com/pivotal-products/data/pivotal-greenplum-database

http://www.datameer.com

http://www.continuuity.com/

http://www.wibidata.com/

http://nltk.org/

http://opennlp.apache.org/

http://code.google.com/p/boilerpipe/

http://www.opencalais.com/

http://www.cs.waikato.ac.nz/ml/weka/

http://mahout.apache.org/

http://scikit-learn.org/stable/

http://www.skytree.net/

http://www.r-project.org/

http://www.graphviz.org/

http://processing.org/

http://mbostock.github.com/protovis/

http://www.tableausoftware.com/

http://support.google.com/fusiontables/

http://support.google.com/fusiontables/


BigData OpenSource



Índice

1 Big Data


3 Ejemplos de uso

4 Ejecución

5 Optimizaciones

6 Implementaciones

7 Conclusiones



¿Qué es MapReduce?

Modelo de programación data-parallel diseñado para escalabilidad y

tolerancia a fallos en grandes sistemas de commodity hardware

Basado en la combinación de operaciones Map y Reduce

Diseñado originalmente por Google (2004)

Usado en múltiples operaciones

Manejo de varios petabytes diarios

Popularizado por la implementación open source Apache Hadoop

Usado por múltiples organizaciones como Facebook, Twitter, Tuenti,

Last.fm, eBay, LinkedIn, Rackspace, Yahoo!, AWS, etc.


http://hadoop.apache.org


¿Para qué se usa?

En Google:

. Construcción de índices para el buscador (pagerank)

. Clustering de artículos en Google News

. Búsqueda de rutas en Google Maps

. Traducción estadística

En Facebook:

. Minería de datos

. Optimización de ads

. Detección de spam

. Gestión de logs

En investigación:

. Análisis astronómico, bioinformática, física de partículas, simulación

climática, procesamiento del lenguaje natural, . . .



Modelo de programación

Inspirado en la programación funcional

Operación Map:

square n = n * n

map op [ ] = [ ]

map op (x : xs) = op x : map op xs

map (square) [1 . .5] => [1 ,4 ,9 ,16 ,25]

Operación Reduce:

reduce op (x : [ ] ) = x

reduce op (x : xs) = (op x (reduce op xs) )

reduce (+) (map (square) [1 . .5 ] ) => 55



Modelo de programación

Entrada y salida: listas de pares clave/valor

El programador especifica las funciones map y reduce

Función Map: genera claves/valores intermedios

map(K1, V1)→ list(K2, V2)

. Para cada K1 y V1 se obtiene una lista intermedia

. (K2, V2) es un par clave/valor intermedio

Funcion Reduce: combina los valores intermedios para cada clave

particular

reduce(K2, list(V2))→ (K3, list(V3))

. Para cada clave de salida K3 se genera una lista de valores

- list(V3) suele tener un único valor

- A menudo, K3 = K2



Automatización del proceso

map map map

Entradas: (Ki1,V

i1) Entradas: (Kj

1,Vj1) Entradas: (Kk

1,Vk1)

(Ki2,V

i2) (Ki

2,Vi2) (Ki

2,Vi2) (Ki

2,Vi2) (Ki

2,Vi2) (Ki

2,Vi2) (Ki

2,Vi2) (Ki

2,Vi2) (Ki

2,Vi2)

Sistema de ficheros distribuido

Barajado y ordenación por valores de claves

reduce reduce

(Ka2,list(Va

2)) (Kb2,list(Vb

2)) (Kc2,list(Vc

2)) (Kd2,list(Vd

2))

(Ka3,V

a3) (Kb

3,Vb

3) (Kc3,V

c3) (Kd

3,Vd

3)



Índice

1 Big Data


3 Ejemplos de uso

4 Ejecución

5 Optimizaciones

6 Implementaciones

7 Conclusiones



Ejemplo: WordCount

Cuenta las ocurrencias de cada palabra en ficheros de texto

Entrada:

K1 = ∅, V1 = línea

Salida:

pares (palabra, nº de ocurrencias)

Pseudocódigo del Map

map(key, value):// key: nada, value: línea de texto

for each word w in value emit(w, 1)

Pseudocódigo del Reduce

reduce(key, values):// key: palabra; values: un iterador sobre los 1s

emit(key, sum(values))



Ejemplo: WordCount

map

En un lugarde la Mancha

Más vale la pena

en el rostro que

la mancha en

el corazón

El amor es deseode belleza

map

map

reduce

reduce

en,1la,1mancha,1vale,1la,1pena,1

un,1lugar,1de,1más,1

Entrada Map Shuffle & Sort Reduce Salida



Ejemplo: WordCount

map


Más vale la pena

en el rostro que

la mancha en

el corazón


map

map

reduce

reduce


en,1rostro,1la,1mancha,1en,1

el,1que,1



Ejemplo: WordCount

map


Más vale la pena

en el rostro que

la mancha en

el corazón


map

map

reduce

reduce


corazón,1amor,1deseo,1

el,1el,1es,1de,1belleza,1



Ejemplo: WordCount

map


Más vale la pena

en el rostro que

la mancha en

el corazón


amor, 1corazón, 1deseo, 1en, 3la, 3mancha, 2pena, 1rostro, 1vale, 1

belleza, 1de, 2el, 3es, 1lugar, 1más, 1que, 1un, 1

map

map

reduce

reduce


amor,1corazón,1deseo,1en,1,1,1la,1,1,1mancha,1,1pena,1rostro,1vale,1

belleza,1de,1,1el,1,1,1es,1lugar,1más,1que,1un,1



Ejemplo: Grep distribuido

Entrada: Ficheros de texto

Salida: Líneas que incluyen el patrón de búsqueda


map(key, value):// key: numero de línea; value: línea de texto

if match(value,pattern) emit(value, 1)

Reduce: Función identidad

. Alternativa: no usar reduce (map-only job)



Ejemplo: Sort distribuido

Entrada: Pares (id, valor)

Salida: Pares ordenados por id

Map: Función identidad

Reduce: Función identidad

Función de particionado P:

k1 < k2 ⇒ P(k1) < P(k2)

map

map

map

reduce

reduce

[A-M]oveja

avispa, hormiga

cerdo

vaca

abeja,elefante

pato, ñu

[N-Z]

abejaavispacerdoelefante hormiga

ñuovejapatovaca



Ejemplo: índice inverso

Entrada: Pares (nombre_fichero, línea_de_texto)

Salida: Pares (palabra, [ficheros_conteniendo_palabra])


map(key, value):// key: nombre del fichero; value: línea de texto

for each word w in value emit(w, key)


reduce(key, values):// key: palabra; value: nombres de ficheros

emit(key, sort(values))



Ejemplo: índice inverso

quij.txt

en un lugar dela mancha, de

cuyo

chej.txt

en su lugar yono iría

(cuyo, [quij.txt])(de, [quij.txt])(en, [chej.txt, quij.txt])(iría, [chej.txt]) (la, [quij.txt])(lugar, [chej.txt, quij.txt]) (mancha, [quij.txt])(no, [chej.txt])(su, [chej.txt])(un, [quij.txt])(yo, [chej.txt])

(en, [quij.txt])(un, [quij.txt])(lugar, [quij.txt])(de, [quij.txt])(la, [quij.txt])(mancha, [quij.txt])(cuyo, [quij.txt])

(en, [chej.txt])

(iría, [chej.txt])

(su, [chej.txt])(lugar, [chej.txt])(yo, [chej.txt])(no, [chej.txt])

Mejora: eliminar duplicados en el map



Ejemplo: palabras más frecuentes

Entrada: Pares (nombre_fichero, línea_de_texto)

Salida: Lista de las palabras que aparecen en más ficheros

Solución con dos fases Map-Reduce

. Fase 1: ejemplo indice inverso

- (palabra, [ficheros_conteniendo_palabra])

. Fase 2:

- Map(palabra, [ficheros])→ (ocurrencias, palabra)

- Resultados ordenados por ocurrencias (como en sort distribuido)



Ejemplo: palabras más frecuentes

(cuyo, [quij.txt])(de, [quij.txt])(en, [chej.txt, quij.txt])(iría, [chej.txt]) (la, [quij.txt])(lugar, [chej.txt, quij.txt]) (mancha, [quij.txt])(no, [chej.txt])(su, [chej.txt])(un, [quij.txt])(yo, [chej.txt])

(1, cuyo)(1, de)(2, en)(1, iría)(1, la)

(2, lugar)(1, mancha)(1, no)(1, su)(1, yo)

(1, cuyo)(1, de)

(2, en)

(1, iría)(1, la)

(2, lugar)

(1, mancha)(1, no)(1, su)(1, yo)



Ejemplo: integración numérica

Entrada: Pares (inicio, final) para los intervalos de integración

Salida: integral de f(x) en un intervalo dado


map(key, value):// key: inicio del rango; value: final del rango

sum=0for(x = key; x < value; x += step)

sum += f(x) * stepemit("", sum)


reduce(key, values):// key: no usado; values: resultados parciales

emit(key, sum(values))



Ejemplo: integración numérica

1 2 3 4 5

0.50.6

(1, 0.5)

(3, 0.6)

(2, 0.58)

(4, 0.59)

(5, 0.57)

1.68

1.16

2.84

Map Reduce

Map 2 (4, 6)

Map 1 (1, 4)



Índice

1 Big Data


3 Ejemplos de uso

4 Ejecución

5 Optimizaciones

6 Implementaciones

7 Conclusiones



Ejecución

Diseñado para

Escalabilidad con grandesvolúmenes de datos

. 1000’s de máquinas

. 10,000’s de discos

Coste reducido

Equipos de bajo coste

. baratos, pero no fiables

Redes de bajo coste

. elevadas latencias

Facilidad de programación

Tolerancia a fallos automática



Problemas en la ejecución

Los nodos baratos fallan, sobre todo si hay muchos

. Tiempo medio entre fallos para 1 nodo = 3 años

. Tiempo medio entre fallos para 1000 nodos = 1 día

. Solución: implementar tolerancia a fallos en el sistema

Red de bajo coste = elevada latencia

. Solución: llevar la computación a los datos

- Minimizar el movimiento de los datos

Dificultad de programación

. Solución: un modelo de programación paralelo intensivo en datos

- Los usuarios escriben funciones map/reduce

- El sistema distribuye el trabajo y maneja los fallos



Características de la ejecución

Sistema de ficheros distribuido para gestionar los datos

. GFS (Google File System), HDFS (Hadoop Distributed FS)

. Ficheros divididos en bloques (chunks o splits) grandes (64-128 MB

en HDFS), con replicación

Arquitectura master-worker

Los map workers se inician en el mismo nodo o rack que sus datosde entrada

. Minimiza el uso de la red

Los map workers graban su salida en el disco local antes de servirlaa los reduce workers

. Permite recuperar una tarea reduce en caso de fallo

Los reduce workers graban su salida en el sistema distribuido

. Replicación en los resultados

. Un fichero de salida por cada reduce



Características de la ejecución

Programa deusuario

master

worker

worker

worker

worker

worker

split 0

split 1

split 2

fichero desalida 0

fichero desalida 1

fork fork fork

asignamaps asigna

reduces

DFS Local DFS

ReadLocal write

Write

Remote read, sort & shuffle



Número de Maps y Reduces

M tareas map y R tareas reduce

Hacer M+R mucho mayor que el número de PEs disponibles

. Mejora la utilización del cluster

Habitualmente, M igual al número de splits de entrada

. Mejora el balance de carga dinámico y acelera la recuperación

cuando falla un worker

R menor que M

. Salida repartida en R ficheros

. Valor ajustable por el usuario

. Función del tipo de problema y los recursos disponibles (memoria, nº

cores,. . . )



Coordinación de las tareas

El Master se encarga de coordinar las diferentes tareas

. Estado de cada tarea: idle, in-progress, completed

. Las tareas idle se planifican a medida que van quedando workers

libres

Cuando una tarea map acaba, le envía al Master la localización y

tamaño de sus R ficheros intermedios, uno por tarea reduce

El Master envía esta información a las tareas reduce



Solapamiento de tareas

La fase de reduce no puede comenzar hasta que se complete la de

map

Se puede simultanear la ordenación/mezcla con la ejecución delmap

. Mejora el balance de carga dinámico

Proceso

Programa

Master

Worker 1

Worker 2

Worker 3

Worker 4

MapReduce()

Asigna tareas a workers

Map 1 Map 3

Map 2

Read 1.1 Read 3.1

Read 1.2

Read 2.1

Read 2.2 Read 3.2

Reduce 1

Reduce 2

Tiempo



Tolerancia a fallos

Mediante heartbeats, el Master detecta fallos en los workers

Si falla una tarea map o reduce

. La tarea se reintenta en otro nodo

- Correcto para los maps porque no tienen dependencias

- Correcto para los reduces porque las salidas de los maps están en

disco

- Necesario que las tareas no tengas efectos colaterales

. Si la misma tarea falla repetidamente, el trabajo MapReduce se

aborta y se notifica al usuario (ajustable)

Si falla un nodo completo

. Relanzar sus tareas en curso en otros nodos

. Reejecutar cualquier map que se hubiera ejecutado en el nodo

- Necesario pues las salidas de los maps se perdieron



Tolerancia a fallos

Si una tarea no progresa (straggler o rezagada)

. Se lanza una segunda copia de la tarea en otro nodo (ejecución

especulativa)

. Se toma la salida de la tarea que acabe antes, y se mata a la otra

. Situación bastante común en clusters grandes

- Debidos a errores hardware, bugs software, fallos de configuración,

etc.

- Una tarea rezagada puede enlentecer de forma importante un trabajo

Si falla el Master

. Se intenta relanzar de nuevo

- Las tareas en proceso o acabadas durante el reinicio, se relanzan

. Si continua fallando, el trabajo se aborta y se le notifica al usuario



Índice

1 Big Data


3 Ejemplos de uso

4 Ejecución

5 Optimizaciones

6 Implementaciones

7 Conclusiones



Combinador

Un combinador (Combiner) es una función de agregación local para

las claves repetidas de cada map

Puede ahorrar ancho de banda al reducir el tamaño de los datos

intermedios del map

combiner(Km2 , list(Vm

2 ))→ (Km3 , list(Vm

3 ))

Habitualmente, misma función que el reducer

Se ejecuta en el mismo nodo que el map

Solo puede utilizarse si la función reduce es commutativa y

asociativa



Combinador

map


Más vale la pena

en el rostro que

la mancha en

el corazón


map

map

reduce

reduce

Entrada Map Shuffle & Sort

Reduce Salida

en,1el,1rostro,1que,1la,1mancha,1en,1 el,1

que,1

combiner

combiner

combiner

en,2rostro,1la,1mancha,1

Combiner



Particionador

El particionador (shuffler) por defecto es un hash de las claves:

. hash(K) mod R

Garantiza:

. Claves iguales van al mismo reducer

. Carga de los reducers relativamente bien balanceada (en muchos

casos)

Hay situaciones en las que puede interesar cambiarlo:

. Ejemplo: hash(hostame(URL)) mod R

. Todas las URLs de cada host se juntan en el mismo fichero de salida



Índice

1 Big Data


3 Ejemplos de uso

4 Ejecución

5 Optimizaciones

6 Implementaciones

7 Conclusiones



Implementaciones

Dos implementaciones más populares:

Hadoop: Implementación open source de MapReduce

Amazon Elastic MapReduce: ejecución de trabajos MapReduce en el

cloud de AWS



Amazon Elastic MapReduce

Proporciona una interfaz web y herramientas CLI para ejecutartrabajos MapReduce en Amazon EC2

. Utiliza trabajos Hadoop

Características principales

. Los datos de entrada y salida se almacenan en Amazon S3

. Las ejecuciones se realizan en máquinas EC2

. Monitoriza los trabajos y “apaga” las máquinas despues de usarlas

. Su uso añade un pequeño coste a la tarifa EC2



Índice

1 Big Data


3 Ejemplos de uso

4 Ejecución

5 Optimizaciones

6 Implementaciones

7 Conclusiones



Conclusiones

El modelo de programación MapReduce oculta la complejidad de la

distribución del trabajo y la tolerancia a fallos

Principales aspectos de diseño:

. Altamente escalable, maneja los fallos hardware

. Reduce los costes del hardware, programación y administración

No es adecuado para todos los problemas, pero cuando funciona

puede ahorrar mucho tiempo

Muy apropiado para la ejecución en la nube


bigdata y mapreduce

Software

datos de sensores

datosvariety datos

lacantidad de datos

veracity datos correctos

apache thrift

apache avro

apache flume

hp cloud