Estudio: Software de tratamiento estadístico y gráfico - R

   En todos mis años de carrera y de investigación estudié y utilicé el Software matemático Matlab para las tareas de procesado, tanto de datos, como de señales. Podemos decir que Matlab es el software más utilizado para el procesado de datos/señales en el ámbito de la investigación.

   Matlab no es un software libre y como consecuencia de esto, en el mundo de la empresa privada es muy común el utilizar R, ya que se distribuye de forma gratuita bajo los términos de la GNU General Public Licence. 

 

    Los archivos necesarios para instalar R (tanto binarios como código fuente, para S.O Linux, Mac o Windows), además de multitud de paquetes con técnicas adicionales a las presentes con la instalación base se pueden encontrar en Comprehensive R Archive Network (CRAN). 

 

   La interfaz de R no es muy "amigable" o atractiva (al ser un proyecto libre importa más la funcionalidad que la apariencia). Existen diversos IDEs (Integrated Development Environment) para hacer más funcional, vistosa y amigable la interfaz con R: RKWard, Tinn-R, RStudio... 

 

   Me he decidido a utilizar RStudio ya que, según he podido intuir tras unas cuantas búsquedas, es el más utilizado, y su interfaz me recuerda a la de Matlab. Página principal de RStudio.

Interfaz de R en Windows

Interfaz de RStudio en Windows

 

 
Instalación en ubuntu

Añadimos el repositorio de R del servidor de España en el archivo /etc/apt/sources.list y lo instalamos:

 ## Repositorio de R
deb http://cran.es.r-project.org/bin/linux/ubuntu precise/

astwin@astwin-H87-HD3:~$ sudo apt-get update
astwin@astwin-H87-HD3:~$ sudo apt-get install r-base
 
   Para instalar RStudio en ubuntu, simplemente nos bajamos el archivo .deb de la pagina web y lo instalamos con el "Ubuntu software center".

R y RStudio en Ubuntu

Manuales, tutoriales y foros

   Una vez instalado y configurado R y RStudio toca buscar tutoriales, manuales, foros... para poder aprender y estudiar R. He encontrado una comunidad española de R, una asociación española de usuarios de R, donde se puede encontrar mucho material para iniciarse y progresar con R.
 
   Revisando unos cuantos manuales, me he decidido iniciar mi andadura en el aprendizaje de R siguiendo el manual R para principiantes (traduccion de R for beginners por J. A. Ahumada), ya que me ha parecido tras una primera ojeada muy completo. 

Laboratorio: Desarrollando una aplicación en MapReduce

Ciclo de desarrollo de un programa en MapReduce

 

A la hora de crear un programa en MapReduce es común seguir las siguientes pautas en el desarrollo:

1. Escribir de forma separada las funciones Map y Reduce, idealmente utilizando test independientes en cada una de ellas para comprobar que funcionan correctamente.
2. Escribir un programa "Driver" que se encarga de configurar y correr el trabajo mapreduce ("job"). Se puede probar y depurar directamente desde el IDE con un conjunto de datos reducido trabajando en local (se pueden utilizar también test para comprobar el Driver).
3. Una vez que el programa funciona tal y como esperábamos con este conjunto de datos reducido, ya se puede ejecutar sobre el cluster para tratar el conjunto completo de datos, donde podemos encontrarnos con otros posibles problemas no considerados en los pasos anteriores. Debugear programas que se ejecutan en un cluster es complejo, debiendo declarar "prints" para obtener logs con información sobre la ejecución de las tareas bien a través de la salida de error standar o bien con mensajes de status de las tareas. Se suelen utilizar también contadores.

En el capítulo 5 del libro "Hadoop: The definitive guide (3rd edition)" se expone un ejemplo de desarrollo de aplicación, en la que se dispone de una datos tomados por diversas estaciones meteorológicas a lo largo de cada día durante 100 años y se pretende obtener la temperatura máxima en cada uno de los años.
 

1 - Escribiendo test unitarios con MRunit

 

Se utiliza un framework estandar de testeo de la ejecución como es JUnit conjuntamente con la librería de testeo MRUnit (usada para poder pasar entradas conocidas a las funciones map y reduce y chequear que las salidas sean las esperadas).

Se escribe la primera versión de cada una de las funciones map y reduce:









Se añaden unos cuantos test con diferentes posibilidades de datos a la entrada para testearlos:

Observamos como la función map que hemos creado no funciona adecuadamente, el test falla con un tipo de datos en concreto a la entrada, lo cuál nos permite poder modificarlo para corregirlo:

La función map no pasa el test.

Tras modificar la funcion map.

2 - Corriendo un trabajo localmente con datos de test

Una vez testeadas las funciones por separado, se crea un programa Driver que configura y ejecuta el job mapreduce y se testea con un conjunto reducido de datos de entrada, en este caso con unos cuantos registros de una estación en los años 1949 y 1950.

 Al trabajar de forma local, podemos utilizar el IDE (eclipse en mi caso), para debugear paso a paso el código:

Eclipse en modo de depuración

Cuando comprobamos que funciona correctamente pasamos a compilarlo, creamos el jar y lo lanzamos en el cluster para procesar los dos primeros años (1901 y 1902) y comprobar si todo va bién:

sudo -u hdfs hadoop jar target/Capitulo_5-1.0.jar ch5.prueba_3.MaxTemperatureDriver /astwin/Ejemplo_weather /astwin/output_red

Laboratorio: Creando mi primera aplicación en MapReduce

Configurando el entorno de desarrollo

   El primer paso para poder crear una aplicación en MapReduce es configurar un entorno de desarrollo, en donde poder escribir las funciones map y reduce. 

 

   Utilizaré Eclipse para desarrollar las aplicaciones MapReduce en Java, utilizando Maven para definir los proyectos:

• Eclipse es un programa informático compuesto por un conjunto de herramientas de programación de código abierto multiplataforma. Esta plataforma, típicamente ha sido usada para desarrollar entornos de desarrollo integrados (del inglés IDE), como el IDE de Java llamado Java Development Toolkit (JDT) y el compilador (ECJ) que se entrega como parte de Eclipse (y que son usados también para desarrollar el mismo Eclipse).
  

• Maven es una herramienta de software para la gestión y construcción de proyectos Java creada por Jason van Zyl, de Sonatype, en 2002. Tiene un modelo de configuración de construcción simple, basado en un formato XML. Es un proyecto de nivel superior de la Apache Software Foundation. Maven utiliza un Project Object Model (POM) para describir el proyecto de software a construir, sus dependencias de otros módulos y componentes externos, y el orden de construcción de los elementos. Viene con objetivos predefinidos para realizar ciertas tareas claramente definidas, como la compilación del código y su empaquetado. Como casi todo el ecosistema de Apache Hadoop está escrito en Java, Maven es una gran herramienta para gestionar proyectos construido sobre las APIs de Hadoop. 

   He de decir que parto de cero, puesto que nunca he utilizado ni Eclipse para desarrollar aplicaciones Java, ni había oído nada sobre Maven, por lo que me he tenido que documentar y estudiar un poquito... Recomiendo unos cuantos enlaces que me han ayudado: 

Primeros pasos con Maven  -  Integrando Maven y Eclipse
Cómo desarrollar aplicaciones CDH con Maven y Eclipse
Usando el repositorio de Maven de CDH5
Manejando las dependencias de la API de Hadoop en CDH5

Creando mi primera aplicación

   En la página de documentación de Cloudera Manager podemos encontrar un pequeño tutorial para crear una aplicación MapReduce que lee todos los ficheros de texto contenidos en un directorio y cuenta el número de veces que aparece cada palabra. 

 

Creamos un proyecto básico en Maven:

astwin@astwin-H87-HD3:~$ mvn archetype:create -DgroupId=astwin.hadoop -DartifactId=Ejemplo_WordCount
[INFO] Scanning for projects...
[INFO]                                                                       
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-archetype-plugin:2.2:create (default-cli) @ standalone-pom ---
[WARNING] This goal is deprecated. Please use mvn archetype:generate instead
[INFO] Defaulting package to group ID: astwin.hadoop
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Old (1.x) Archetype: maven-archetype-quickstart:RELEASE
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: astwin.hadoop
[INFO] Parameter: packageName, Value: astwin.hadoop
[INFO] Parameter: package, Value: astwin.hadoop
[INFO] Parameter: artifactId, Value: Ejemplo_WordCount
[INFO] Parameter: basedir, Value: /home/astwin
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: /home/astwin/Ejemplo_WordCount
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 0.790s
[INFO] Finished at: Wed Mar 12 11:28:23 CET 2014
[INFO] Final Memory: 8M/239M
[INFO] ------------------------------------------------------------------------     
astwin@astwin-H87-HD3:~$ cd Ejemplo_WordCount/
astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ sudo gedit pom.xml

Modificamos el archivo pom.xml para configurar el proyecto:

 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>astwin.hadoop</groupId>
  <artifactId>Ejemplo_WordCount</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>EjemploWordCount</name>
  <url>http://maven.apache.org</url>

  <repositories>
    <repository>
      <id>cloudera</id>
      <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
    </repository>
  </repositories>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-client</artifactId>
      <version>2.2.0-cdh5.0.0-beta-1</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

    <build>
      <pluginManagement>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
              <source>1.6</source>
              <target>1.6</target>
            </configuration>
          </plugin>
        </plugins>
      </pluginManagement>
    </build>

</project>

Creamos el proyecto para cargarlo con el IDE (Eclipse):

astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ mvn eclipse:eclipse -DdownloadSources=true -DdownloadJavadocs=True

Lo importamos en Eclipse, añadimos las clases de la aplicación y construimos el archivo JAR.

Proyecto WordCount compilado

Ejecutando mi primera aplicación

Almacenando en HDFS los ficheros

astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ hadoop fs -mkdir /astwin/Ejemplo_WordCount
astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ echo "uno dos dos tres tres tres" > file01
astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ echo "Ejecutando mi primer programa creado en MapReduce" > file02
astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ hadoop fs -put file* /astwin/Ejemplo_WordCount
astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ hadoop fs -ls /astwin/Ejemplo_WordCount
Found 2 items
-rw-r--r--   3 astwin supergroup         27 2014-03-12 11:44 /astwin/Ejemplo_WordCount/file01
-rw-r--r--   3 astwin supergroup         50 2014-03-12 11:44 /astwin/Ejemplo_WordCount/file02
astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ hadoop fs -cat /astwin/Ejemplo_WordCount/file01
uno dos dos tres tres tres
astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ hadoop fs -cat /astwin/Ejemplo_WordCount/file02
Ejecutando mi primer programa creado en MapReduce

Ejecutando el programa

astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ sudo -u hdfs hadoop jar /home/astwin/Ejemplo_WordCount/target/Ejemplo_WordCount-1.0-SNAPSHOT.jar astwin.hadoop.WordCount /astwin/Ejemplo_WordCount /astwin/Ejemplo_WordCount/output
...
14/03/12 11:51:33 INFO mapreduce.Job: Running job: job_1394612204892_0002
14/03/12 11:51:37 INFO mapreduce.Job: Job job_1394612204892_0002 running in uber mode : false
14/03/12 11:51:37 INFO mapreduce.Job:  map 0% reduce 0%
14/03/12 11:51:41 INFO mapreduce.Job:  map 33% reduce 0%
14/03/12 11:51:42 INFO mapreduce.Job:  map 67% reduce 0%
14/03/12 11:51:44 INFO mapreduce.Job:  map 100% reduce 0%
14/03/12 11:51:48 INFO mapreduce.Job:  map 100% reduce 20%
14/03/12 11:51:49 INFO mapreduce.Job:  map 100% reduce 40%
14/03/12 11:51:51 INFO mapreduce.Job:  map 100% reduce 80%
14/03/12 11:51:52 INFO mapreduce.Job:  map 100% reduce 100%
14/03/12 11:51:53 INFO mapreduce.Job: Job job_1394612204892_0002 completed successfully
14/03/12 11:51:53 INFO mapreduce.Job: Counters: 43
......

Comprobamos la salida

Comprobamos como la salida es la esperada:
 

astwin@astwin-H87-HD3:~/Ejemplo_WordCount$ hadoop fs -cat /astwin/Ejemplo_WordCount/output/part*
creado    1
mi    1
dos    2
en    1
tres    3
MapReduce    1
primer    1
programa    1
Ejecutando    1
uno    1

Laboratorio: Ejecutando el primer programa en Mapreduce

Tal y como se indica en los manuales de Cloudera Manager, para testear la instalación se puede lanzar un ejemplo de un programa para estimar el valor de pi en Mapreduce. Esta tarea lleva a cabo una simulación para estimar el valor de Pi basándose en un muestreo de puntos. El programa primero mapea una serie de puntos a unos ficheros, uno por tarea map. Luego calcula una estimación de Pi basándose en esos puntos, en la propia tarea MapReduce:

sudo -u hdfs hadoop jar /usr/lib/hadoop-mapreduce/hadoop-mapreduce-examples.jar pi 10 100   

Number of Maps  = 10
Samples per Map = 100
Wrote input for Map #0
Wrote input for Map #1
Wrote input for Map #2
Wrote input for Map #3
Wrote input for Map #4
Wrote input for Map #5
Wrote input for Map #6
Wrote input for Map #7
Wrote input for Map #8
Wrote input for Map #9
Starting Job
14/03/10 18:01:09 INFO client.RMProxy: Connecting to ResourceManager at astwin-H87-HD3/10.42.0.12:8032
14/03/10 18:01:10 INFO input.FileInputFormat: Total input paths to process : 10
14/03/10 18:01:10 INFO mapreduce.JobSubmitter: number of splits:10
14/03/10 18:01:10 INFO mapreduce.JobSubmitter: Submitting tokens for job: job_1394469409802_0007
14/03/10 18:01:10 INFO impl.YarnClientImpl: Submitted application application_1394469409802_0007
14/03/10 18:01:10 INFO mapreduce.Job: The url to track the job: http://astwin-H87-HD3:8088/proxy/application_1394469409802_0007/
14/03/10 18:01:10 INFO mapreduce.Job: Running job: job_1394469409802_0007
14/03/10 18:01:18 INFO mapreduce.Job: Job job_1394469409802_0007 running in uber mode : false
14/03/10 18:01:18 INFO mapreduce.Job:  map 0% reduce 0%
14/03/10 18:01:22 INFO mapreduce.Job:  map 20% reduce 0%
14/03/10 18:01:24 INFO mapreduce.Job:  map 30% reduce 0%
14/03/10 18:01:25 INFO mapreduce.Job:  map 40% reduce 0%
14/03/10 18:01:26 INFO mapreduce.Job:  map 50% reduce 0%
14/03/10 18:01:27 INFO mapreduce.Job:  map 60% reduce 0%
14/03/10 18:01:28 INFO mapreduce.Job:  map 70% reduce 0%
14/03/10 18:01:29 INFO mapreduce.Job:  map 80% reduce 0%
.....

.....
Job Finished in 24.515 seconds
Estimated value of Pi is 3.14800000000000000000

Laboratorio: "Jugando" con Hadoop HDFS

Hadoop HDFS

   El Hadoop Distributed File System (HDFS) es un sistema de archivos distribuido, escalable y portátil escrito en Java para el framework Hadoop. 

 

   Cada nodo en una instancia Hadoop típicamente tiene un único nodo de datos; un clúster de datos forma el clúster HDFS. La situación es típica porque cada nodo no requiere un nodo de datos para estar presente. Cada nodo sirve bloques de datos sobre la red usando un protocolo de bloqueo específico para HDFS. El sistema de archivos usa la capa TCP/IP para la comunicación; los clientes usan RPC para comunicarse entre ellos. El HDFS almacena archivos grandes (el tamaño ideal de archivo es de 64 MB), a través de múltiples máquinas. Consigue fiabilidad mediante replicado de datos a través de múltiples hosts, y no requiere almacenamiento RAID en ellos. Con el valor de replicación por defecto, 3, los datos se almacenan en 3 nodos: dos en el mismo rack, y otro en un rack distinto. Los nodos de datos pueden hablar entre ellos para reequilibrar datos, mover copias, y conservar alta la replicación de datos.

 

   HDFS no cumple totalmente con POSIX porque los requerimientos de un sistema de archivos POSIX difieren de los objetivos de una aplicación Hadoop, porque el objetivo no es tanto cumplir los estándares POSIX sino la máxima eficacia y rendimiento de datos. HDFS fue diseñado para gestionar archivos muy grandes. HDFS no proporciona Alta disponibilidad.
 

Interfaz de linea de comandos de HDFS

hadoop fs <argumentos>     

Comandos Posix

• cat - The cat utility shall read files in sequence and shall write their contents to the standard output in the same sequence.
• chgrp - Change the file group ownership
• chmod - change the file modes
• chown - change the file ownership
• cp - copy files
• dv - estimate file space usage
• ls - list directory contents
• mkdir - make directories
• mv - move files
• rm - remove directory entries
• stat - get file status
• tail - copy the last part of a file

Comandos específicos de HDFS

• copyFromLocal
• copyToLocal
• get
• getmerge
• put
• setrep

Usando HDFS

Crear una carpeta en sistema distribuido y cambiarle el propietario (usuario astwin); debemos utilizar sudo con el usuario hdfs, para obtener permisos de creación de la carpeta en el directorio raíz del sistema de archivos distribuido (una vez le cambiamos el propietario al directorio /astwin ya podemos realizar operaciones sobre ella con el usuario astwin):

 
sudo -u hdfs hadoop fs -mkdir hdfs:///astwin     
sudo -u hdfs hadoop fs -chown astwin:supergroup hdfs:///astwin     

Copiar los archivos del libro "Hadoop The Definitive Guide 3rd Edition" descargados hacia una carpeta llamada hadoop-book-3e:
 
hadoop fs -mkdir hdfs:///astwin/hadoop-book-3e 
hadoop fs -put file:///home/astwin/Descargas/hadoop-book-3e/ hdfs:///astwin/hadoop-book-3e

Copiar los archivos con los datasets con datos de estaciones meteorológicas (dataset reducido, con sólo los datos de 1901 y 1902) con los que se trabaja en el libro:
 
hadoop fs -mkdir hdfs:///astwin/Ejemplo_weather/    
hadoop fs -put file:///home/astwin/Descargas/1901 hdfs:///astwin/Ejemplo_weather/   
hadoop fs -put file:///home/astwin/Descargas/1902 hdfs:///astwin/Ejemplo_weather/   

Listamos el directorio distribuido /astwin para ver que se han creado las dos carpetas con los archivos y datos utilizados en el libro:
 
hadoop fs -ls hdfs:///astwin  
Found 2 items  
drwxr-xr-x   - astwin supergroup          0 2014-02-27 10:39 hdfs:///astwin  /Ejemplo_weather  
drwxr-xr-x   - astwin supergroup          0 2014-02-27 10:34 hdfs:///astwin/hadoop-book-3e  

Podemos navegar también por el sistema de archivos distribuido utilizando el UI (user interface) web de Cloudera Manager:

Navegando por el sistema de archivos HDFS con UI Web

 

Laboratorio: Instalando Hadoop - Cloudera Manager

Distribuciones que integran Hadoop

   Hadoop es un framework libre escrito en Java que facilita tanto el almacenaje distribuido, como la escritura de aplicaciones distribuidas. Algunos componentes de Hadoop son hoy extremadamente popular:

• MapReduce: plataforma para procesado en paralelo una tarea o un calculo en grandes cantidades de datos.
• HBase: base de datos distribuida para grandes volúmenes de datos.
• HDFS: sistema de ficheros distribuido.

   Con el fin de facilitar la configuración e instalación de Hadoop, existen diversas distribuciones, tales como Cloudera o Hortonworks entre otras.

   La distribución de Cloudera (CDH) fue la primera en aparecer en el mercado, combinando Big Data y Hadoop. CDH no solo incluye el núcleo de Hadoop (HDFS, MapReduce…) sino que también integra diversos proyectos de Apache (HBase, Mahout, Pig, Hive, etc.). CDH es 100% open-source, y cuenta con una interfaz gráfica propietaria, Cloudera Manager, para la administración y gestión de los nodos del clúster Hadoop. La descarga es totalmente gratuita. No obstante, también cuenta con una versión empresarial, que incluye una interfaz más sofisticada. 

Instalando Cloudera Manager

   Para seguir mi andadura en el mundo de Hadoop, después de haber realizado el curso online de introducción en bigdatauniversity.com (con prácticas en el utilizando una imagen con un sistema Linux para wmware con el software IBM biginsights ya configurado)  pretendo instalar y configurar Hadoop por mi cuenta y montarme un pequeño cluster compuesto por mi nuevo ordenador de sobremesa y mi viejo portatil. 

Esquema de mini-cluster hadoop administrado con Cloudera Manager

   El primer paso ha sido escoger e instalar una distribución de Linux en ambos ordenadores. Me he decantado por instalar la distribución ubuntu 12.04 LTS (long-term support release). Una vez instalado y correctamente configurado el sistema operativo en ambos ordenadores (después de luchar para conseguir hacer funcionar el wifi en ambos ordenadores, he podido hacer funcionar el wifi en el portatil, y compartir la conexión a Internet con el de sobremesa a través del cable de red ... los fabricantes y su escaso interés en proporcionar drivers para Linux...).

   He decidido instalar Hadoop mediante la distribución de Cloudera a través de la aplicación Cloudera Manager. He instalado Cloudera Enterprise 5 Beta 2 (incorpora la distribución de Hadoop de cloudera CDH 5 Beta 2) en el ordenador de sobremesa. Se accede inicialmente a la consola de administración a través de la dirección/puerto http://127.0.0.1:7180, con usuario/contraseña admin/admin.

   Una vez instalado Cloudera Manager en el ordenador de sobremesa y para poder instalar y configurar CDH sobre los host que componen el cluster, según se indica en la guía de instalación:

• Uniform SSH access to cluster hosts on the same port from Cloudera Manager Server host.
• You must log in to the Cloudera Manager Server host using a root account or an account that has password-less sudo permission. 
• Cluster hosts must have a working network name resolution system. Properly configuring DNS and reverse DNS meets this requirement.

   Para que la aplicación Cloudera Manager tenga acceso a ambos ordenadores a través de SSH he instalado Open SSH en los dos:

sudo apt-get install openssh-client   

sudo apt-get install openssh-server 

   Para que Cloudera Manager pueda instalar los paquetes necesarios y configurarlos, necesita acceder mediante SSH como usuario root o como un usuario con permisos sudo sin que se requiera contraseña. La cuenta root viene desactivada por defecto en Ubuntu, por lo que voy a conceder permisos sudo (permite a los usuarios tener ciertos privilegios sobre el sistema, acercándose a root,) a un usuario en cada uno de los ordenadores sin que requiera contraseña.
   Los parámetros de que usuario está dentro de sudo y que usuario no lo está, se encuentran en el archivo sudoers, así que lo tendré que editar:
 

sudo gedit /etc/sudoers   

   Doy permiso sudo sin contraseña al usuario astwin (usuario en ordenador de sobremesa) y usuario peset (usuario en ordenador portatil), añadiendo una linea al final del archivo sudoers: 
 

astwin ALL=(ALL) NOPASSWD:ALL  #(Sobremesa)

peset ALL=(ALL) NOPASSWD:ALL    #(Portatil)

   Otro requerimiento es que todos los host del cluster deber ser capaces de resolver DNS y DNS inversa hacia el resto de host. Al tener ambos ordenadores conectados en red mediante cable, compartiendo el Internet wifi del portátil al ordenador de sobremesa, se puede conseguir "bypaseeando" la búsqueda DNS en cada uno de los host a través del fichero /etc/hosts:

sudo gedit /etc/hosts  

   Así queda el contenido del fichero hosts en cada uno de los ordenadores: 
 
127.0.0.1    localhost.localdomain                 localhost    
10.42.0.12  astwin-H87-HD3.local                astwin-H87-HD3 
10.42.0.1    peset-dv6-Notebook-PC.local     peset-dv6-Notebook-PC

   Desde la consola de administración, en el apartado de host, le clickeamos  a añadir nuevos hosts al cluster para añadir los dos ordenadores y automáticamente instalar y pre-configurar CDH en cada uno de ellos.
 

Ordenador portatil

Ordenador sobremesa

 
¡Ya dispongo de mi primer mini cluster de dos ordenadores con Hadoop! Podemos comprobar con el inspector de hosts que todo está ok, corriendo CDH 5 sobre cada uno de los ordenadores.
 

Inspector de host: todo Ok.

Cluster

Estudio: Capítulo 8 - Características avanzadas en MapReduce.

Capítulo 8 del libro "Hadoop: The Definitive Guide, 3rd Edition". Se introducen diferentes características y utilidades que incorpora MapReduce que pueden ser de ayuda, como son los contadores y la posibilidad de ordenar y unir datasets.
 

1 – Contadores. 

   Los contadores son un canal muy útil para poder obtener estadísticos sobre los datos procesados durante un determinado trabajo MapReduce y también para utilizarlos en tareas de debugging.

   Hadoop incorpora algunos contadores para cada trabajo que reportan diferentes métricas. En este apartados se presentan diferentes contadores integrados en Hadoop que recogen información tanto generales sobre el trabajo, como particulares sobre las diferentes tareas que lo componen.

   Aparte de los contadores que integra Hadoop, un programador puede añadir contadores personalizados utilizando el API de Java. 

1.1 – Contadores integrados.

1.1.1 – Contadores de tareas.
1.1.2 – Contadores de trabajos.

1.2 – Contadores definidos por el usuario en Java.

1.2.1 – Contadores dinámicos .
1.2.2 – Nombres de contadores legibles.
1.2.3 – Obtener el valor de los contadores.

1.3 – Contadores definidos por el usuario en Streaming.

2 – Ordenación de datos. 

Hadoop posee inherentemente una etapa de ordenación de datos en la etapa de shuffle, lo que se considera el corazón de Hadoop.  En este apartadoo se examinan diferentes formas de ordenar datasets y como se puede controlar el orden de la ordenación en MapReduce. Es preferible utilizar Pig o Hive para realizar tareas de ordenamiento de datos.

Una de las clases más interesantes que se presenta en este apartado es InputSampler, la cuál permite muestrear el espacio de las keys y obtener un subset reducido de datos. 

2.1 – Preparación.

2.2 – Ordenación parcial.

2.3 – Ordenación total.

2.4 – Ordenación secundaria.

3 – Unión de datasets. 

Al igual que sucede con la ordenación de datos, es preferible utilizar Pig, Hive o Cascading para realizar operaciones de unión de datasets en vez de escribir programas en MapReduce. 

3.1 – Uniones desde el proceso map.

3.2 – Unión desde el proceso reduce.

4 – Datos adicionales. 

   En determinados trabajos puede ser necesario algún tipo de información (sólo lectura) extra para procesar el conjunto de datos que componen el dataset. Se debe proporcional acceso a los datos adicionales en todas las tareas map o reduce (están esparcidas a lo largo de todo el cluster) de una forma eficiente. Se pueden añadir diferentes parejas arbitrarias de key/value en la configuración de un trabajo (muy útil para pasar cantidades de datos no muy elevados como metadatos para accedidos por las tareas), o se puede utilizar el mecanismo de caché distribuida que proporciona Hadoop.

   La caché distribuida proporciona un servicio para copiar ficheros a los nodos que ejecutan las tareas en el momento preciso en el que los necesitan para ejecutarse.

4.1 – Utilizando la configuración de un trabajo.

4.2 – Caché distribuida.

Estudio: Capítulo 7 - Tipos y formatos de datos en Mapreduce

Capítulo 7 del libro "Hadoop: The Definitive Guide, 3rd Edition". Se realiza una revisión sobre cómo el modelo MapReduce permite trabajar con archivos de datos en varios formatos desde el API de Java, desde archivos de texto plano a objetos binarios estructurados.
 

1 – Tipos MapReduce. 

Esquema general del flujo de key/value en MapReduce:

map: (K1, V1) → list(K2, V2)
reduce: (K2, list(V2)) → list(K3, V3)

En el caso de poder utilizar una funcion combine :

map: (K1, V1) → list(K2, V2)
combine: (K2, list(V2)) → list(K2, V2)
reduce: (K2, list(V2)) → list(K3, V3)

Clases de API de Java: Mapper (clase Context y método map()), Reducer (clase Context y método reduce()) [cuando se utiliza una funcion combine se realiza mediante una implementación de Reducer], Partitioner (método getPartition(), opera con la key intermedia K2 para obtener el índice de la partición).

   Diferentes clases y métodos deben definir el tipo de datos de las key/value con los que operarán. Son clases diferentes, y aunque el tipo de datos deban coincidir (por ejemplo, K2,V2 declarados como salida de map deben ser los mismos K2,V2 declarados como entrada de reduce), el compilador de Java no lo fuerza, ya que la configuración no se chequea en tiempo de compilación; los conflictos de tipos de datos se detecten en tiempo de ejecución.

   En este apartado se indica los parámetros de configuración y propiedades que deben coincidir en tipo al programar un trabajo MapReduce con la API de Java. 

1.1 – El trabajo MapReduce por defecto.

   Se analiza un trabajo MapReduce escrito utilizando la API de Java sin especificar el mapper ni el reducer (se utiliza las funciones map y reduce por defecto) para ilustrar el funcionamiento de la API y poder entender mejor cómo trabaja MapReduce y el flujo de datos a través de las funciones map y reduce. 

1.1.1 – El trabajo Streaming por defecto.
1.1.2 – Key/Value en Streaming.

2 - Formatos de entrada. 

   Hadoop puede procesar diferentes tipos de formatos de ficheros con datos. Un Input Split es una partición de los datos de entrada que es procesada por un mapper. Cada Input Split esta dividido en registros, y cada proceso map procesa cada registro (en un formato key/value) de forma secuencial. El concepto de los Splits y los registros es algo lógico, no existe nada que los ate a los ficheros.

Los Input Splits estan representados por la clase InputSplit. Escribiendo una aplicación MapReduce no manegas esta clase directamente, sino que manejas una clase InputFormat que es la responsable de creal los splits y dividirlos en registros. La clase FileInputFormat es la clase base de InputFormat que utiliza ficheros como su origen de datos.

En este apartado se introducen diferentes clases derivadas de InputSplit para lidiar con diferentes tipos de ficheros de entrada y su partición en splits y registros.

2.1 – Input Splits y registros.

2.1.1 – FileInputFormat.
2.1.2 – Paths de entrada en FileInputFormat.
2.1.3 – Input Splits en FileInputFormat.
2.1.4 – Ficheros pequeños y CombineFileInputFormat.
2.1.5 – Previniendo el particionado.
2.1.6 – Información de los ficheros en el mapper.
2.1.7 – Procesando todo un fichero como un registro.

2.2 - Entrada de texto.

2.2.1 – TextInputFormat.
2.2.2 – KeyValueTextInputFormat.
2.2.3 – NLineInputFormat.
2.2.4 – XML.

2.3 – Entrada binaria.

2.3.1 – SequenceFileInputFormat.
2.2.2 – SequenceFileAsTextInputFormat.
2.3.3 - SequenceFileAsBinaryInputFormat.

2.4 – Múltiples entradas.

2.5 – Entradas (y salidas) desde bases de datos.

3 – Formatos de salida. 

   Al igual que se definen formatos de ficheros que actuan como entrada de datos, se definen los ficheros de salida que recogen los datos procesados. La clase OutputFormat  define el tipo y propiedades de estos ficheros de salida.

3.1 – TextOutput.

3.2 – Salida binaria.

3.2.1 – SequenceFileOutputFormat.
3.2.2 – SequenceFileAsBinaryOutputFormat.
3.2.3 - MapFileOutputFormat.

3.3 – Salidas múltiples.

3.4 – Salida 'Lazy' (despreocupada).

3.5 – Salida hacia base de datos.