Han pasado casi 6 años desde los artículos de Mordiendo Hadoop: Mordiendo Hadoop: Instalación y primeras pruebasMordiendo Hadoop: Instalación en Cluster y Mordiendo Hadoop: Desarrollo de aplicaciones MapReduce. En ese tiempo el ecosistema de Hadoop se ha enriquecido, su arquitectura ha cambiado y su uso se ha extendido, convirtiéndose en la referencia de tecnología para Big Data. En estos años hemos realizado varias instalaciones de Hadoop en el grupo de Ingeniería de Información de la universidad, tanto para los cursos de maestría como para proyectos de pregrado y postgrado.

Desde hace poco más de 3 años, usamos la distribución de HortonWorks, HDP, por su facilidad de instalación (a través de ambari), por ser de código abierto y por su estabilidad. Cada vez es más fácil realizar la instalación, pero todo depende de la configuración previa de los nodos. En este artículo describiré la instalación de HDP, los pasos preliminares y las lecciones aprendidas que pueden ser aplicadas a nuevas instalaciones ( una traducción-resumen de la documentación oficial, con algunos consejos).

Preparación

Antes de iniciar la instalación de la plataforma HDP, debemos asegurarnos de cumplir con unos prerrequisitos:

  1. Tener instalado en los nodos un sistema operativo soportado (Recomendados para HDP 2.3: Centos 6.x o 7.x). Consejo: Instalar el sistema operativo en inglés, ambari en ocasiones tiene problemas con la codificación de caracteres cuando el sistema operativo tiene un idioma diferente.
  2. Desde la que será la máquina host de ambari el usuario root debe poder autenticarse sin contraseña a las otras máquinas del cluster.
  3. Todas las máquinas deberían tener la hora sincronizada (usando ntp), el servicio de ntp debe estar configurado para iniciar al iniciar el sistema operativo.
  4. Todas las máquinas deben ser alcanzables por nombre de dominio. (DNS es la mejor opción, si no es posible se puede lograr agregándolas al /etc/hosts de todas las máquinas).
  5. Cada máquina debe tener correctamente configurado su FQDN (es una continuación del punto anterior). En especial, si la máquina tiene más de una interfaz de red debemos asegurarnos que siempre resuelva su nombre de dominio con la misma dirección IP (y que sea la que está en el segmento del cluster).
  6. El número máximo de descriptores de archivos abiertos (el número máximo de archivos abiertos de forma simultanea) debe ser de, como mínimo, 10000 (el recomendado es 65536 ). Se puede verificar usando ulimit -Snulimit -Hn (Límite suave y fuerte respectivamente) y se puede cambiar usando ulimit -n 10000.
  7. Desactivar SELinux  y configurar el firewall para que las máquinas del cluster puedan comunicarse entre ellas por los puertos apropiados, y permitir el acceso de los usuarios a los servicios.  Se recomienda desactivar el firewall durante el proceso de instalación, e iniciarlo y configurarlo apropiadamente una vez la instalación esté completa.
  8. Debemos tener una idea de cómo vamos a distribuir los servicios en el cluster (en qué máquinas tendremos los servicios maestros y en cuáles tendremos los esclavos y los clientes).

Instalación

Antes de iniciar la instalación debemos determinar cuál será la máquina dedicada como host de Ambari. En esta máquina debemos:

  1. Configurar el repositorio:
    wget -nv http://public-repo-1.hortonworks.com/ambari/centos7/2.x/updates/2.1.0/ambari.repo -O /etc/yum.repos.d/ambari.repo
    
  2. Instalar ambari-server:
    yum install ambari-server
  3. Configurar ambari-server:
    ambari-server setup
    1. Seleccione el JDK deseado (Oracle JDK 1.8 es una buena opción). Debe aceptar la licencia para continuar con la instalación.
    2. Si desea tener una manejador de bases de datos diferente a postgres para ambari, seleccione la configuración avanzada. En caso contrario acepte el valor por defecto (En ese caso se creará en Postgres una base de datos llamada ambari; El usuario por defecto será ambari y contraseña bigdata).
  4. Inicie el servidor ambari:
    ambari-server start
  5. Desde un navegador web ingresar al servidor de ambari, http://<fqdn del servidor de ambari>:8080
    • Ingresar con el nombre de usuario y contraseña por defecto (admin /admin).Bienvenida de ambari
    • Al ingresar podrá crear un nuevo cluster usando el asistente, manejar los usuarios y grupos que pueden acceder a ambari y desplegar vistas.
    • Al iniciar el asistente para la creación de un nuevo cluster le solicitará un nombre. Debe ser descriptivo, porque es la forma de identificar el cluster en ambari.
      ambari2
    • El segundo paso del asistente es seleccionar la versión de HDP a instalar.  Si las máquinas tendrán conexión a Internet durante la instalación sólo es necesario indicar la versión, en caso contrario es necesario abrir las opciones avanzadas y configurar la dirección del repositorio local que se utilizará.
      ambari3
    • En el siguiente paso se agregan los nombres de las máquinas que harán parte del cluster, una por línea o utilizando expresiones.  También debe indicar la llave privada ssh autorizada para acceder a los nodos del cluster.  (Si realizó correctamente el paso 2 de la preparación, la llave privada probablemente estará en /root/.ssh/id_rsa del host de ambari)
      ambari4Si utilizó expresiones aparecerá una ventana confirmando los nombres
      ambari4.1
    • En el siguiente paso se instalará el agente de ambari en los hosts seleccionados y se pueden eliminar nodos que no se quieran incluir en el cluster.
      ambari5
    • A continuación es necesario seleccionar los servicios que se desean en el cluster.
      ambari6
    • Luego debemos seleccionar dónde quedaran los componentes maestros de estos servicios.
      ambari8
    • También seleccionar en qué nodos quedarán los componentes esclavos y los clientes de los servicios.
    • Antes de la revisión final y la instalación, debemos personalizar la configuración de los servicios. Ambari hace recomendaciones de acuerdo a las características de los nodos, que pueden ser usados como valores por defecto, sin embargo conviene revisarlas y es necesario completar las configuraciones que aparecen marcadas en rojo (para las cuales no hay un valor pre-establecido).
      ambari9
    • Luego se realiza una revisión final y se procede a la instalación, configuración y prueba de los servicios.
      ambari10
      ambari11
      El proceso de instalación puede tomar varios minutos, pero es completamente automático. Si hay una falla en alguno de los procesos se puede hacer clic en el mensaje para obtener el log (para determinar la causa). Son comunes los problemas de conexión con los servidores espejo, por lo que la solución más común es reintentar la instalación. Al finalizar verá el resumen de la instalación y podrá ir al tablero de control, en el cual puede ver cuáles servicios están activos, cuáles inactivos, los recursos utilizados, ver las alertas y realizar tareas de administración (por ejemplo, agregar un nuevo servicio al cluster, iniciar o detener un servicio y modificar la configuración).
      ambari12
      ambari13
      ambari14

El proceso de instalación es sencillo, semiautomático y permite tener rápidamente un entorno funcional. Sin embargo, se debe tener en cuenta que esta instalación es sólo un punto de arranque y se deben definir políticas para el uso de los recursos (generalmente más de un usuario utilizará el cluster) e ir ajustando la configuración de acuerdo a las métricas obtenidas.

 

Spark

Apache Spark es un framework de computación en paralelo, que promete velocidades hasta 100 veces mayores a las de Hadoop Map Reduce. Puede correr de manera local (en uno o varios hilos) o en cluster sobre Apache Mesos, Hadoop YARN, o en modo Standalone.

En este pequeño ejemplo crearemos un proyecto en eclipse con las dependencias necesarias para Spark y desarrollaremos un contador de palabras. Spark tiene API nativas para Scala, Python y Java. En este ejemplo usaremos Java 8.

Lo primero que haremos será crear un proyecto Maven en Eclipse:

Nuevo proyecto Maven en Eclipse Luna

En este caso seleccionamos el arquetipo por defecto, e introducimos el id del grupo y el id del artefacto que deseemos para nuestra aplicación.

El siguiente paso es añadir las dependencias al archivo pom.xml, así:

<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>uniandes.bigdata</groupId>
 <artifactId>sparkDemo</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>jar</packaging>

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

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

 <dependencies>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>3.8.1</version>
 <scope>test</scope>
 </dependency>
 <dependency>
 <groupId>org.apache.spark</groupId>
 <artifactId>spark-core_2.10</artifactId>
 <version>1.0.1</version>
 <scope>provided</scope>
 </dependency>
 </dependencies>
</project>

La dependencia de spark tiene groupId org.apache.spark, artifactId spark-core_2.10 y versión 1.0.1. Utilizaremos el scope provided para que no se empaqueten las librerías en el jar que generaremos.

Nuestra clase WordCount tendrá la siguiente estructura,

package uniandes.bigdata.sparkDemo;

import java.util.Arrays;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.JavaRDD;

import scala.Tuple2;

/**
 * WordCount en Spark
 *
 */
public class WordCount
{
    /**
     * Recibe como parámetro la ruta del archivo de entrada.
     * Puede ser un archivo local o una ruta hdfs (hdfs://...)
     * */
    public static void main( String[] args )
    {
        String file=null;
        /**Recibir como parámetro el nombre del archivo
         **/
        if(args.length>0){
            file=args[0];
        }else{
            System.err.println("No se puede ejecutar sin un archivo");
            return;
        }
        //El nombre de la aplicación:
        SparkConf conf = new SparkConf().setAppName("PruebaSpark");
        //La aplicación se puede ejecutar en local para probar en desarrollo.
        //Cuando se ejecuta desde spark (usando spark-submit)
        //no se debe especificar el master:

        //conf.setMaster("local[*]");//Descomentar esta línea para probar localmente
        JavaSparkContext sc = new JavaSparkContext(conf);

        /*Lee un archivo de texto en el RDD. El archivo puede ser local, estar ubicado en el hdfs
          o en cualquier fuente soportada por Hadoop
        */
        JavaRDD<String> texto=sc.textFile(file);

        //Utilizamos las funciones de Spark, junto con las expresiones lambda de Java 8,
        //para crear una colección de palabras (usando flatMap),
        //crear un mapa con la palabra como llave y 1 como valor (mapToPair),
        //y reducirlo por llave de tal forma que obtenemos un mapa con la palabra como llave
        //y el número de apariciones como valor (reduceByKey)

        JavaPairRDD<String, Integer> byKey = texto.flatMap(l->Arrays.asList(l.split("\\s")))
                    .mapToPair(s->new Tuple2<String, Integer>(s.toLowerCase(),1))
                    .reduceByKey((a,b)->a + b);

        //Guardamos el resultado, como archivo de texto

        byKey.saveAsTextFile("salida");
    }
}

La aplicación se puede probar localmente descomentando la línea conf.setMaster(“local[*]”);. La cadena local[*] indica que se ejecute con tantos hilos como procesadores en la máquina local. Podemos especificar el número de hilos (e.g. local[2]), dar la ruta a un servidor Mesos o Spark, o especificar que use Hadoop YARN (usando “yarn-client” o “yarn-cluster”). Cuando se va a ejecutar la aplicación usando spark-submit, no se debe especificar en la aplicación la url del máster (se puede pasar como parámetro a spark-submit).

Instalar spark y ejecutar la aplicación

La instalación de spark se limita a descargar y descomprimir el paquete indicado. Si se desea usar Yarn, es necesario descargar los binarios compilados con compatibilidad para Hadoop 2, y asegurarse que las variables de entorno HADOOP_HOME, HADOOP_CONF y YARN_CONF están correctamente establecidas.

Después de generar el jar usando maven, podemos ejecutar la aplicación usando spark-submit:

spark-submit --verbose --master local --class uniandes.bigdata.sparkDemo.WordCount "rutaAljar\sparkDemo-0.0.1-SNAPSHOT.jar" "rutaAlArchivo\test.txt"

Un problema común en Windows, si no se tiene instalada la distribución de Hadoop de Hortonworks, es que la aplicación falle porque Spark no encuentra winutils.exe, que se debería encontrar en la carpeta %HADOOP_HOME%/bin. Este archivo se puede descargar del repositorio de HDP, como indican en uno de los foros de Azure.

 

Conclusiones

El no estar limitado al paradigma MapReduce, el uso de RDD (Resilient Distributed Dataset), junto con el uso de expresiones lambda (Java 8, Scala y python), hacen que el proceso de escribir una aplicación para Spark sea intuitivo. Algunas de las características de Spark se ven cuando se ejecutan varias tareas sobre un mismo dataset, dado que puede compartir datos en memoria entre diferentes trabajos.

Spark es una alternativa interesante, especialmente en aplicaciones que requieren iteraciones y reuso de los datos (como el análisis de grafos y aprendizaje de máquina). Proyectos como GraphX  y Spark Streaming, hacen aún más interesante este framework.

 

Los recomendados de la semana llegan mezclando algo de reflexión, comics, social media, entre otras cosas:

  • ¿Por qué marchan los estudiantes?, en contravía, expone los  argumentos de los estudiantes, frente a los del gobierno, sobre la ley 30. Entre otros recursos, la vicerrectoría de sede Bogotá de la universidad Nacional de Colombia ha puesto a disposición del público una recopilación de documentos sobre la reforma para su discusión. 
  • El poyecto “Rooftop” busca rediseñar los trajes de los superheroes de toda la vida. Reciben permanentemente contribuciones, que únicamente deben cumplir sus guidelines.
Project : Rooftop – P:R Redesign : Michelle Sciuto’s Harley Quinns!
Con esto terminan los recomendados de la semana, para cerrar los dejo con el último vídeo de Simon’s Cat  😆
Hadoop Logo

En los post anteriores instalamos Hadoop en un nodo, tanto en modo standalone como pseudo-distribuido, y en un cluster de dos nodos, ahora revisaremos la creación de una aplicación MapReduce.

Hadoop Logo

Para estas pruebas configuraremos un ambiente de desarrollo usando una instalación en modo pseudo-distribuida, eclipse y el plugin de Hadoop para éste IDE. También se puede usar la maquina virtual de entrenamiento proveída por Cloudera, que incluye una instalación de Hadoop, ejemplos, eclipse, entre otras herramientas. Para ejecutar ésta máquina virtual se puede usar VMWare Player. Una vez descargada la imagen de la maquina virtual se descomprime, se abre el archivo .vmx con VMPlayer.

Configuración del entorno de desarrollo

Para nuestro ambiente de desarrollo iniciamos con una máquina con Hadoop configurado en modo pseudo-distribuido, descargamos e instalamos eclipse, y procedemos con la instalación del plugin de Hadoop:

  1. Establecer las variables de entorno JAVA_HOME y HADOOP_HOME, con la ruta a la carpeta raiz de Java y Hadoop respectivamente.
  2. Copiar el plugin de hadoop a la carpeta de plugins de eclipse.
    cp $HADOOP_HOME/contrib/eclipse-plugin/hadoop-0.20.2-eclipse-plugin.jar PATH_TO/eclipse/plugins/
  3. Iniciamos Eclipse.
  4. Abrimos la perspectiva Map/Reduce. Window->Open Perspective->Others->Map/Reduce
  5. Entramos en la vista MapReduce Locations.
  6. Clic derecho sobre la lista MapReduce Locations, seleccionar New Hadoop location.
  7. Le damos un nombre a la nueva ubicación, y configuramos el host y puerto tanto del MapReduce master(JobTracker) cómo del dfs.master (NameNode).
  8. Ahora en el explorador de proyectos podremos ver los archivos de nuestro sistema de archivos distribuido en DFS Locations.

Ahora tenemos listo nuestro ambiente de desarrollo, a continuación crearemos una aplicación MapReduce.

Crear una nueva aplicación

El plugin de Hadoop nos crea un nuevo tipo de proyecto en eclipse y tres tipos de archivo Mapper, Reducer y MapReduce Driver. Para crear nuestra nueva aplicación crearemos un proyecto MapReduce:

Continuar leyendo

En un post anterior realizamos la instalación de hadoop en un nodo, tanto en modo standalone como pseudo-distribuido. Ahora realizaremos la instalación en dos nodos.

Hadoop Logo

Un par de cosas a tener en cuenta:

  • De acuerdo a la documentación, típicamente se tiene un nodo como NameNode y otro como JobTracker. Los demás nodos serán configurados como DataNode y TaskTracker.
  • Aunque no es obligatorio, es recomendable que los nodos tengan el mismo HADOOP_HOME, directorio raíz de la distribución.

Lo primero por hacer es descargar Hadoop, descomprimirlo en lo que será nuestro HADOOP_HOME, y configurar el JAVA_HOME dentro de conf/hadoop-env.sh.

wget http://apache.mirrors.tds.net//hadoop/core/stable/hadoop-0.20.2.tar.gz
tar -xvf hadoop-0.20.2.tar.gz
vim hadoop-0.20.2/conf/hadoop-env.sh

Para distribuir un poco la carga configuraremos el NameNode en una máquina y el JobTracker en otra. También configuraremos los dos nodos como TaskTracker y DataNode.

Para ello debemos modificar el archivo de configuración conf/core-site.xml con la url del que será el NameNode.

<configuration>

<property>

<name>fs.default.name</name>

<value>hdfs://namenode:9000</value>

</property>

</configuration>

Para especificarle a Hadoop en donde almacenar los bloques de datos del DFS se puede usar la propiedad dfs.data.dir y como valor la ruta del directorio, en el archivo conf/hdfs-site.xml. En éste archivo es necesario configurar la replicación de los bloques, el valor predeterminado es 3, en éste caso solo tenemos dos nodos así que utilizaremos un valor de dfs.replication de 2.

<configuration>
<property>
<name>dfs.data.dir</name>
<value>/data/hadoopdd</value>
</property>
<property>

<name>dfs.name.dir</name>

<value>/data/hadoopnd</value>

</property>
<property>
<name>dfs.replication</name>
<value>2</value>
</property>
</configuration>

Debemos especificar la ubicación del JobTracker, lo hacemos en el archivo de configuración mapred-site.xml. En este archivo también configuramos donde se almacenarán los archivos temporales.

<configuration>

<property>

<name>mapred.job.tracker</name>

<value>157.253.236.228:54311</value>

</property>

<property>

<name>mapred.local.dir</name>

<value>/data/hadoopmr</value>

</property>

</configuration>

Debemos asegurarnos que podemos iniciar sesión ssh sin contraseña en las dos máquinas, para ello seguimos los pasos indicados para la instalación en un solo nodo y, además, agregar las llaves públicas ssh de las máquinas master en el archivo .ssh/authorized_keys máquinas slave:

$ ssh-keygen -t dsa -P '' -f ~/.ssh/id_dsa

$ cat ~/.ssh/id_dsa.pub >> ~/.ssh/authorized_keys

$ ssh-copy-id -i .ssh/id_dsa.pub {ip_slave}

Los siguientes archivos solo se deben editar en los master(en este caso en los dos nodos, pero al agregar un nuevo nodo solo se modifican en los NameNode y JobTracker).

En el archivo conf/masters se listan los nodos master, tanto NodeName como JobTracker, en el archivo conf/slaves todos los nodos DataNode y TaskTracker, uno por línea.

Formateamos el sistema de archivos distribuido, ejecutando en el NameNode:

./hadoop-0.20.2/bin/hadoop namenode -format

Arrancamos los demonios de hdfs, ejecutando

bin/start-dfs.sh

Podemos los procesos ejecutados en cáda maquina usando el comando jps.

A continuación iniciamos los demonios de Mapreduce, ejecutando en el JobTracker:

bin/start-mapred.sh

Para detener los demonios del sistema de archivos y de mapreduce, respectivamente, ejecutamos:

bin/stop-dfs.sh
bin/stop-mapred.sh

Ahora deberíamos poder correr el ejemplo que utilizamos en la instalación anterior:

$ bin/hadoop fs -put conf input

$ bin/hadoop jar hadoop-*-examples.jar grep input/conf output 'dfs[a-z.]+'

Sin embargo se pueden presentar algunos problemas en el dfs, por un bug que aún se encuentra abierto. En http://www.michael-noll.com/wiki/Running_Hadoop_On_Ubuntu_Linux_(Multi-Node_Cluster) podemos ver otro tutorial(en ingles) de la instalación del cluster, con una configuración un poco diferente, y las alternativas para resolver los problemas que se pueden presentar.

En un próximo artículo revisaremos el desarrollo de una aplicación MapReduce para Hadoop.

 

Hadoop Logo

Hadoop es un framework para computación distribuida que soporta aplicaciones con uso intensivo de datos. Implementa, entre otras cosas, el paradigma MapReduce y HDFS, un sistema de archivos distribuido y el principal sistema de almacenamiento en Hadoop.

En esta primera aproximación probaré la instalación y ejecución de Hadoop, haciendo un resumen de los pasos necesarios, traduciéndolos, y comentarios al margen frente a la documentación.

Los prerrequisitos de Hadoop son Java 1.6, ssh server y rsync, en Windows será necesario también Cygwin. Para éstas pruebas usaré una máquina virtual con Debian 5.0.5, Java 1.6.0_20, openssh 5.1p1.

La instalación de Hadoop se reduce a descargar la versión estable y descomprimirlo:

wget http://apache.mirrors.tds.net//hadoop/core/stable/hadoop-0.20.2.tar.gz
tar -xvf hadoop-0.20.2.tar.gz
Ahora, entrando a la carpeta que se descomprimió, se edita conf/hadoop-env.sh definiendo la variable JAVA_HOME con la ubicación de la instalación de java, en teoría funcionaría si la variable JAVA_HOME está definida en el entorno, pero es mejor definirla en el archivo para facilitar la distribución. A continuación se puede ejecutar el comando:
bin/hadoop
Para ver  la documentación de uso.
Existen 3 configuraciones posibles de Hadoop: Standalone, pseudo-distribuida y distribuida. La configuración predeterminada es Standalone, no distribuida y un solo proceso de java, útil para depuración según la documentación. Con ésta instalación se puede ejecutar el primer ejemplo de Hadoop, un grep basado en MapReduce:
$ mkdir input
$ cp conf/*.xml input
$ bin/hadoop jar hadoop-*-examples.jar grep input output 'dfs[a-z.]+'
$ cat output/*

La salida crea dos archivos: part-0000 con la respuesta y .part-0000.crc con el CRC checksum.

Para ejecutar Hadoop en el modo Pseudo-distribuido, varios nodos en una máquina en procesos java diferentes, debemos modificar los archivos conf/core-site.xml, conf/hdfs-site.xml y conf/mapred-site.xml así:

conf/core-site.xml:

<configuration>

<property>

<name>fs.default.name</name>

<value>hdfs://localhost:9000</value>

</property>

</configuration>

conf/hdfs-site.xml:

<configuration>

<property>

<name>dfs.replication</name>

<value>1</value>

</property>

</configuration>

conf/mapred-site.xml:

<configuration>

<property>

<name>mapred.job.tracker</name>

<value>localhost:9001</value>

</property>

</configuration>

En el ambiente de pruebas funciona ssh a localhost sin contraseña, sin embargo esto puede no ser cierto en todos los ambientes. En el manual de Hadoop describen la forma configurarlo para ese caso. Esto sólo es necesario si no se puede hacer ssh a localhost sin contraseña:

$ ssh-keygen -t dsa -P '' -f ~/.ssh/id_dsa

$ cat ~/.ssh/id_dsa.pub >> ~/.ssh/authorized_keys

Ahora podemos ejecutar hadoop, primero creando un nuevo sistema de archivo distribuido, para luego ejecutar los nodos

$ bin/hadoop namenode -format
$ bin/start-all.sh

Ahora podemos acceder a la interfaz web del Job Tracker y del Namenode en el puerto 50030 y 50070 respectivamente.

Ahora ejecutaremos el ejemplo con el que probamos el Singlenode, para lo cual necesitamos copiar los archivos de entrada al sistema de archivos distribuido, en el cual también se crearán los archivos de salida, para hacer visibles las diferencias entre los dos modos se pueden borrar las carpetas input y output creadas anteriormente. Para ejecutar el ejemplo hacemos:

$ rm -rf input output

$ bin/hadoop fs -put conf input

$ bin/hadoop jar hadoop-*-examples.jar grep input output 'dfs[a-z.]+'

Ahora los archivos de salida están en el sistema de archivos distribuido, para traerlos ejecutamos:

$ bin/hadoop fs -get output output
$ cat output/*

o podemos ver el resultado directamente en el sistema de archivos distribuido:

bin/hadoop fs -cat output/*

Cuando terminamos podemos detener los nodos ejecutando:

$ bin/stop-all.sh

La salida incluye además de la respuesta los logs de la ejecución.

En un próximo post revisaremos la configuración de Hadoop en modo distribuido en un Cluster de máquinas.

Hadoop Logo