Download Desarrollo de un entorno basado en MapReduce para la ejecución

UNIVERSIDADE DA CORUÑA
FACULTAD DE INFORMÁTICA
Departamento de Electrónica y Sistemas
PROYECTO FIN DE CARRERA DE INGENIERÍA
INFORMÁTICA
Desarrollo de un entorno basado en
MapReduce para la ejecución distribuida
de algoritmos genéticos paralelos
-.Consideraciones técnicas.-
Autor: Alberto Luengo Cabanillas
Directores: Xoán Carlos Pardo Martínez
Patricia González Gómez
A Coruña, 21 de Septiembre de 2010
Índice general
I
Índice general
CONSIDERACIONES TÉCNICAS ____________________________________________________1
1.
INSTALACIÓN DEL SOFTWARE ____________________________________________________1
1.1
Prerrequisitos ____________________________________________________________1
1.2
Cygwin__________________________________________________________________1
1.3
Entorno virtualizado con Hadoop _____________________________________________2
1.4
Instalando VMWare Player __________________________________________________3
1.4.1 Configurando el Entorno Virtual ____________________________________________________ 4
1.4.2 Cuentas de usuario de la máquina virtual ______________________________________________ 5
1.4.3 Ejecutando un trabajo Hadoop ______________________________________________________ 5
1.4.5 Accediendo a la máquina virtual mediante ssh__________________________________________ 6
1.4.6 Apagando la máquina virtual _______________________________________________________ 7
1.5
Preparando Eclipse ________________________________________________________7
1.5.1 Descarga e instalación ____________________________________________________________ 7
1.5.2 Instalación del plugin Hadoop MapReduce ____________________________________________ 8
1.5.3 Haciendo una copia de Hadoop _____________________________________________________ 8
1.5.4 Ejecutando Eclipse _______________________________________________________________ 8
1.5.5 Configurando el plugin Hadoop MapReduce ___________________________________________ 9
1.6
PigPen: Plugin de Pig Latin para Eclipse______________________________________11
1.7
Interactuando con el HDFS_________________________________________________12
1.7.1 Usando la línea de comandos ______________________________________________________ 12
1.7.2 Usando el plugin MapReduce para Eclipse ___________________________________________ 13
1.8
Lanzando un programa de prueba____________________________________________13
1.8.1 Creación del Proyecto____________________________________________________________ 14
1.8.2 Creación de los archivos fuente ____________________________________________________ 14
1.8.3 Lanzando el trabajo contra el HDFS_________________________________________________ 15
2.
MANUAL DE USUARIO DEL PROYECTO MRPGA _____________________________________19
3.
MANUAL DE PROGRAMADOR DEL PROYECTO MRPGA ________________________________23
Índice de capturas
III
Índice de capturas
CAPTURA 1: MÁQUINA WINDOWS VIRTUALIZANDO MÁQUINA LINUX ........................................................3
CAPTURA 2: INSTALACIÓN VMWARE PLAYER .........................................................................................4
CAPTURA 3: LISTADO DE SERVIDORES MAPREDUCE EN ECLIPSE 3.5........................................................10
CAPTURA 4: PLUGINS DE PIG Y HADOOP INSTALADOS EN ECLIPSE 3.5 .....................................................12
CAPTURA 5: CÓDIGO JAVA CLASE WORDCOUNTMAPPER .......................................................................16
CAPTURA 6: CÓDIGO JAVA CLASE WORDCOUNTREDUCER......................................................................17
CAPTURA 7: CÓDIGO JAVA CLASE WORDCOUNT ....................................................................................18
CAPTURA 8: RESULTADO EJECUCIÓN TRABAJO MR WORDCOUNT ...........................................................19
CAPTURA 9: MENÚ JAVA BUILD PATH EN ECLIPSE 3.5............................................................................20
CAPTURA 10: EDICIÓN DE PARÁMETROS DE LA APLICACIÓN EN ECLIPSE 3.5 ............................................21
CAPTURA 11: RESULTADOS DE EJECUCIÓN DEL PROYECTO MRPGA EN ECLIPSE 3.5 ................................22
Consideraciones Técnicas
Página | 1
Consideraciones Técnicas
A lo largo de este documento se abarcarán las cuestiones más técnicas del
desarrollo del sistema, desde su configuración e instalación hasta su ejecución y uso. En
la primera sección se procede a desarrollar un breve tutorial con los pasos necesarios
para configurar el entorno adecuado de ejecución para la aplicación. En la sección 2 se
incluye un manual de usuario en el que se explica la manera de ejecutar un AG
determinado en el framework que se ha implementado y por último, en la tercera
sección se incluye un breve manual para el programador que desee modificar alguna de
las decisiones de implementación llevadas a cabo (p.ej. diferente operador de cruce o
selección, diferente codificación de la población, etc.).
1. Instalación del Software
A continuación se detallan los pasos seguidos para poder replicar el entorno en
el que se ha desarrollado la aplicación.
1.1
Prerrequisitos
Desarrollar programas para Hadoop requiere un entorno de programación Java.
Se
puede
descargar
un
kit
de
http://java.sun.com/javase/downloads/index.jsp)
desarrollo
para
una
Java
(JDK)
multitud
de
(desde
sistemas
operativos. Hadoop requiere la versión 6 de Java Standard Edition (Java SE) que es la
más actual a la hora de escribir estas líneas.
1.2
Cygwin
Para poder conectarse a la máquina virtual sobre la que está montada nuestra
distribución de Hadoop es necesario tener un nombre de usuario conforme a alguno de
los existentes en la máquina virtual. Dicha comprobación la realiza el plugin conector
de Eclipse cuando necesite conectarse al HDFS remoto, mediante el valor que devuelve
el comando Unix whoami. Dicho comando no es nativo de Windows, por lo que se
vuelve necesario tener un entorno Unix dentro de Windows desde el que lanzar Eclipse
para que se comporte correctamente.
Página | 2
La
Consideraciones Técnicas
solución
más
sencilla
pasa
por
descargar
e
instalar
Cygwin
(http://www.cygwin.com/) a la máquina local. Este proceso es sumamente sencillo: solo
hace falta descargar el instalador setup.exe de su página web y ejecutarlo para que
se inicie el asistente que guiará al usuario durante todo el proceso de instalación.
Hadoop funciona razonablemente bien en Cygwin, pero, oficialmente, es solo
para propósitos de investigación. Hadoop en Cygwin puede ser inestable, e instalar el
propio Cygwin puede resultar incómodo ya que no posee un asistente de instalación al
uso.
1.3
Entorno virtualizado con Hadoop
Esta sección explica cómo configurar una máquina virtual que ejecute Hadoop
dentro del ordenador anfitrión.
Los usuarios de Linux, MacOS, u otros entornos de estilo Unix son capaces de
instalar Hadoop y ejecutarlo en una o más máquinas sin necesidad de más software a
mayores que Java. Si el lector está interesado en esta opción, existen instrucciones
disponibles en la página web de Hadoop en la sección de quickstart documentation
(http://hadoop.apache.org/common/docs/r0.20.1/quickstart.html).
Para facilitar la primera aproximación a Hadoop a los programadores, es
interesante contar con una imagen de una máquina virtual que traiga una distribución de
Hadoop preconfigurada. La imagen virtual se ejecutará dentro de un entorno sandbox
en el que se podrá ejecutar otro sistema operativo. El SO dentro del sandbox no sabe
que existe otro entorno operativo exterior a él; actúa como si estuviese en su propio
ordenador. Este entorno sandbox es conocido como “máquina cliente”, ejecutando un
sistema operativo cliente. La máquina física que ejecuta el software de virtualización se
llama “máquina anfitrión” y ejecuta el sistema operativo anfitrión. La máquina virtual
facilita otras aplicaciones de tal forma que simula que existe otra máquina física en la
misma red. Las aplicaciones que se ejecutan en la máquina anfitrión ven la máquina
virtual como una máquina aparte con su propia dirección IP, y pueden interactuar con
los programas dentro de la máquina virtual de esta forma (véase Captura 1).
Para finalizar, comentar que la máquina virtual también se puede ejecutar siendo
Linux el sistema anfitrión, con las mismas características de conexión que en el caso
anterior.
Instalación del Software
Página | 3
Captura 1: Máquina Windows virtualizando máquina Linux
1.4
Instalando VMWare Player
La máquina virtual descargada en el apartado anterior está diseñada para
ejecutarse en VMWare Player (http://www.vmware.com). Se pueden descargar copias
del instalador de VMWare Player tanto para Linux en formato rpm, bundle o para
Windows. En particular en el caso de Windows, se ejecuta como un asistente de
instalación cualquiera.
Si se está utilizando un sistema operativo distinto, o se prefiere descargar una
versión más reciente de VMWare Player, una instalación alternativa consiste en acceder
a http://info.vmware.com/content/GLP_VMwarePlayer y registrarse para solicitar un
virtualization starter kit. A partir de ahí, se recibirá un e-mail con un enlace de descarga
con sus instrucciones correspondientes.
Página | 4
Consideraciones Técnicas
1.4.1 Configurando el Entorno Virtual
Una vez descargada la máquina virtual en un directorio del disco duro de la
máquina anfitrión, habrá que descomprimirla y hacer doble click sobre el fichero
hadoop-appliance-0.18.0.vmx. Cuando se arranca la máquina virtual por
primera vez, VMWare Player reconocerá que la imagen de la máquina virtual no está en
la misma localización en la que solía estar, como se puede apreciar en la Captura 2;
habrá que indicarle que se ha copiado y no que se ha movido. VMWare Player generará
entonces nuevos identificadores de sesión para esta instancia. Si posteriormente se
mueve a una localización diferente del disco duro, se le debería indicar a VMWare
Player dicha operación.
Una vez se elija una opción, se arrancará Linux de manera normal, asignándole
una dirección IP sin usar en la red y mostrando un prompt para que el usuario se
autentique.
Captura 2: Instalación VMWare Player
Instalación del Software
Página | 5
1.4.2 Cuentas de usuario de la máquina virtual
La máquina virtual viene configurada con dos usuarios: hadoop-user (con
contraseña hadoop) y root (con contraseña root). La cuenta del primero tiene permisos
sudo para ejecutar funciones de administración del sistema, tales como apagar la
máquina virtual. Es muy recomendable arrancar Hadoop con este usuario y no como
root, ya que puede haber algún problema de autenticación con el HDFS.
Una vez autenticados, las primeras tareas a realizar serían las siguientes:

Cambiar la distribución del teclado al idioma español: mediante el
comando sudo dpkg-reconfigure console-setup.

Cambiar la hora del sistema: mediante los comandos date y
hwclock
Igualmente, si hiciese falta, y antes de arrancar Hadoop, se debería actualizar
éste a la versión que interesase –generalmente, a la del plugin de Eclipse con el que se
va a comunicar. Las directivas para llevar a cabo esto se encuentran en la wiki del
proyecto Hadoop: http://wiki.apache.org/hadoop/.
1.4.3 Ejecutando un trabajo Hadoop
Una vez arrancada la máquina virtual como usuario hadoop-user, lo primero que
se debe hacer es arrancar Hadoop mediante el siguiente comando:
hadoop-user@hadoop-desk:~$ ./start-hadoop
Si, por lo contrario, se ha instalado Hadoop en la máquina anfitrión, la secuencia
de comandos sería la siguiente (asumiéndose que se ha instalado en ~/hadoop):
usuario@maquina:~$ cd hadoop
usuario@maquina:~/hadoop$ bin/start-all.sh
Aparecerán una serie de mensajes indicando si la operación ha ido bien o mal. Si
pregunta si es correcto conectarse a la máquina anfitrión actual, se debe contestar
afirmativamente.
Hecho esto, se procederá a ejecutar un programa ejemplo para asegurarse que el
sistema está correctamente configurado:
Página | 6
Consideraciones Técnicas
hadoop-user@hadoop-desk:~$ cd hadoop
hadoop-user@hadoop-desk:~/hadoop$ bin/hadoop jar hadoop0.18.0-examples.jar pi 10 1000000
La salida debería ser similar a lo siguiente:
Wrote input for Map #1
Wrote input for Map #2
Wrote input for Map #3
...
Wrote input for Map #10
Starting Job
INFO mapred.FileInputFormat: Total input paths to process:
10
INFO mapred.JobClient: Running job: job_200806230804_0001
INFO mapred.JobClient: map 0% reduce 0%
INFO mapred.JobClient: map 10% reduce 0%
...
INFO mapred.JobClient: map 100% reduce 100%
INFO mapred.JobClient: Job complete: job_200806230804_0001
...
Job Finished in 25.841 second
Estimated value of PI is 3.141688
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, obteniendo los resultados arriba mostrados.
1.4.5 Accediendo a la máquina virtual mediante ssh
En vez de utilizar directamente el terminal de la máquina cliente, se puede
autenticar el usuario en el sistema de forma remota mediante ssh desde la máquina
anfitrión. Usando un cliente ssh como Putty (http://www.putty.org/) (bajo Windows),
solo hace falta configurar la IP de la máquina cliente (visible al arranque de la misma o
mediante el comando ifconfig, en el campo innet_addr). Nos pedirá el
nombre de usuario y contraseña y se podrá interactuar con esta máquina virtual como si
existiese otra máquina Linux en la red.
Esto solo se puede hacer desde la máquina anfitrión. La imagen de VMWare
Player está configurada por defecto para recibir peticiones únicamente de la máquina
anfitrión a través de su interfaz de red. Por motivos de seguridad, la máquina virtual no
Instalación del Software
Página | 7
aparece en la red externa actual. Sin embargo, si se quisiese cambiar esto, se podría
reconfigurar la máquina virtual para permitir acceso por red a cualquier máquina a
través de su IP. En este caso, se deberían cambiar las contraseñas asociadas a las
cuentas de la máquina virtual para impedir que usuarios desautorizados pudiesen hacer
login con la contraseña por defecto.
1.4.6 Apagando la máquina virtual
Una vez se haya acabado de trabajar con ella, la máquina virtual se puede apagar
mediante el comando sudo poweroff, deteniéndose automáticamente todos los
demonios Hadoop que se estuviesen ejecutando.
1.5
Preparando Eclipse
Eclipse es uno de los entornos de desarrollo de aplicaciones basadas en Java más
utilizados del mundo. Es un entorno integrado de desarrollo (IDE) de código abierto.
Soporta múltiples lenguajes a través de la instalación de complementos o plugins. En
esta sección se verá cómo obtener, configurar y usar Eclipse.
1.5.1 Descarga e instalación
El sitio web de descargas de Eclipse (http://www.eclipse.org/) ofrece una gran
variedad de versiones de descarga, basándose sobre todo en el perfil de programador
que lo va a utilizar. La última revisión estable a la hora de escribir estas líneas es la 3.6,
con el nombre en clave “Helios”. Sin embargo, debido al tiempo de desarrollo del
proyecto no se utilizó dicha revisión, sino la anterior (versión 3.5.2, nombre en clave
“Galileo”), la cual es compatible con el plugin de Hadoop que se mostrará a
continuación (aunque la anterior versión 3.4 –nombre en clave “Ganímedes”- es
incompatible). De entre las que se encuentran disponibles para descarga, se debería
escoger para descargar bien Eclipse classic 3.5.2, o bien Eclipse IDE for Java
developers.
Al estar escrito en Java, Eclipse se puede migrar fácilmente de una plataforma a
otra, por lo que está disponible tanto en Windows, como en MacOS, como en Linux.
Instalar Eclipse es casi inmediato: viene comprimido en un fichero .zip que se
descomprimirá en un directorio y se instalará de forma habitual, creando un acceso
Página | 8
Consideraciones Técnicas
directo a su ejecutable en caso de Windows o tecleando eclipse desde una consola de
Linux.
1.5.2 Instalación del plugin Hadoop MapReduce
Dentro del directorio hadoop-0.18.0/contrib/eclipse-plugin en el
sistema de ficheros de la máquina virtual instalada se encuentra el fichero hadoop0.18.0-eclipse-plugin.jar que se deberá copiar al subdirectorio plugins/
del directorio de instalación de Eclipse.
Si el lector descubre que el plugin en cuestión no funciona con su versión de
Eclipse, puede optar por buscarlo en el repositorio de código de Google asociado a este
proyecto (http://code.google.com/p/mrpga/) –en el que se pueden encontrar varios
plugins compilados específicamente correspondientes a distintas versiones de Hadoopo, si se dispone de la herramienta de gestión de proyectos Ant (http://ant.apache.org/),
compilar
uno
nuevo
manualmente
mediante
el
comando
ant
-
Declipse.home=<dir de instalación de Eclipse> clean package
(situándose en la carpeta raíz del directorio con el código fuente de Hadoop).
1.5.3 Haciendo una copia de Hadoop
Mientras se están ejecutando los trabajos MapReduce en la máquina cliente,
éstos se compilan en la máquina anfitrión, por lo que va a ser necesario tener una copia
de Hadoop en un directorio del disco duro local. Esta copia o bien se puede obtener
desde un repositorio o bien mediante clientes SCP para Windows como WinSCP
(http://winscp.net/).
1.5.4 Ejecutando Eclipse
Para arrancar Eclipse, primero es necesario ejecutar Cygwin, ya que de esta
manera se podrá conectar el plugin de Hadoop al HDFS de la máquina cliente con un
nombre de usuario adecuado. El sistema de rutas en Cygwin varía con respecto al de
Windows, convirtiendo el árbol de directorios en una estructura similar a los sistemas
Unix. Por ello, para ejecutar Eclipse, al igual que todas las aplicaciones Windows habrá
que acceder a la ruta de instalación que será del estilo /cygdrive/c/eclipse. Ya
Instalación del Software
Página | 9
dentro del directorio, se arrancará Eclipse a través del comando ./eclipse.exe –
clean.
La primera vez que se ejecute Eclipse, pedirá especificar un directorio como
workspace, en el que almacenará datos de configuración, ficheros objeto, etc. Una vez
introducido, se accederá a una pantalla de bienvenida en la que se podrá empezar a
trabajar.
1.5.5 Configurando el plugin Hadoop MapReduce
En este apartado se verá cómo activar la perspectiva MapReduce dentro de
Eclipse y cómo conectarse a la máquina virtual de Hadoop. Para ello, se deben seguir
los siguientes pasos:
1. Arrancar Hadoop y la máquina virtual si no se ha hecho todavía de las formas
anteriormente descritas.
2. Desde la parte superior derecha del área de trabajo, pulsar el botón “Open
Perspective” (el que tiene forma de cuadro con una estrella en su esquina
superior derecha) seguido de “Other...” para que explore todas las perspectivas
disponibles en el sistema (ya que, por defecto, no cargará la perspectiva
MapReduce). De momento, nada parece cambiar, pero desde el menú “Window->Show view-->Other” se abrirá un menú con todas las vistas cargadas. Debajo
de “MapReduce Tools” se deberá elegir “Map/Reduce locations”, lo que hará
que aparezca un nuevo panel visible en el fondo de la pantalla, cercano a
“Console”.
3. En “Window-->Preferences”, dentro del apartado “Hadoop Map/Reduce” se
indicará el directorio donde esté almacenada la copia local de la distribución
correspondiente de Hadoop.
4. En el panel “Map/Reduce locations” recién creado, se debe hacer click sobre el
logo del elefante para añadir un nuevo servidor MapReduce a Eclipse, como se
muestra en la Captura 3.
En este paso será necesario introducir un número de parámetros identificativos del
servidor, los cuales en el caso de querer conectarse a la imagen virtualizada son:
Location name: (Any descriptive name you want; e.g.,
"VMware server")
Página | 10
Consideraciones Técnicas
Map/Reduce
startup)
Map/Reduce
DFS Master
User name:
Master Host: (The IP address printed at
Master Port: 9001
Port: 9000
hadoop-user
Captura 3: Listado de servidores MapReduce en Eclipse 3.5
El paso siguiente es ir a la pestaña “Advanced”, donde hay dos parámetros que
es necesario cambiar:

hadoop.job.ugi. Contiene las credenciales de login actuales de
Windows. Hace falta reemplazar el primero de los valores –el nombre del
usuario actual – por hadoop-user.

mapred.system.dir: Hay que cambiarlo por
/hadoop/mapred/system
Una vez configurados estos parámetros aparecerá una nueva entrada bajo el
árbol DFS Locations en el explorador de Proyectos de Eclipse. Haciendo click sobre el
símbolo “+” se expandirá el árbol de directorios del HDFS remoto pudiendo ver su
estructura si se ha configurado correctamente.
Instalación del Software
1.6
Página | 11
PigPen: Plugin de Pig Latin para Eclipse
PigPen es un plugin de Eclipse que ayuda a los usuarios a crear scripts en Pig
Latin, probarlos usando el generador de ejemplos y enviarlos a un clúster Hadoop.
El plugin en formato .JAR está disponible en la wiki del conector PigPen:
http://wiki.apache.org/pig/PigPen.
Asimismo,
es
recomendable
descargar
una
distribución de Pig completa desde los repositorios habilitados a tal efecto
(http://hadoop.apache.org/pig/releases.html) y el proyecto PigPen completo (disponible
en el repositorio Google de código de este proyecto: http://code.google.com/p/mrpga/).
Obsérvese por último que no todas las versiones de las distribuciones de Pig son
compatibles con todas las versiones de Hadoop, por lo que se debe elegir con cuidado.
El jar descargado se debe situar en el subdirectorio /plugins del directorio de
instalación de Eclipse. Una vez hecho esto, hay que ejecutar Eclipse y dirigirse a "Help
->Install new software", introducir la ruta local de la carpeta de la distribución de Pig y
desmarcar la casilla "Group items by category" (hay que estar conectado a Internet para
que se resuelvan las dependencias que faltan). Ahora hay que configurar la variable
"ClassPath" que apunte al directorio de PigPen y el jar de Pig al directorio anterior.
Hecho esto, si se ha importado el plugin correctamente, aparecerá una nueva
perspectiva “Pig Latin” (accesible desde el menú “Window-->Open Perspective->Other...”) y un nuevo conjunto de botones en la parte superior izquierda con los logos
de dos cerdos y un elefante amarillo, tal y como muestra la Captura 4.
El uso más habitual en entornos de producción es embeber Pig en una aplicación
Java para que se conecte Pig al HDFS. Para ello, crearemos un fichero que contenga un
script
Pig
Latin
sencillo
(se
pueden
encontrar
varios
en
http://wiki.apache.org/pig/PigLatin) hay que pinchar con el botón derecho sobre el
fichero ejemplopig.java que hayamos creado, irse a "Run Configurations" y de
ahí a la pestaña "ClassPath". En esa pestaña, pinchar en "User Entries", pulsar
"Advanced" y elegir "Add external folder". Finalmente, elegir la carpeta de Pig que
contenga los ficheros pig.properties y hadoop-site.xml. Si todo ha ido bien, ya se podrá
ejecutar el proyecto como "Run as Java Application".
El último paso de configuración es indicar la ubicación del fichero pig.jar, para
ello, dentro del menú “Window-->Preferences”, en el apartado “Pig”, se indicará la ruta
local a dicho fichero (y si no existe, se deberá crear).
Página | 12
Consideraciones Técnicas
Para finalizar, si ahora se quisiera probar el "Example Generator" que trae
PigPen y aparece un mensaje de error es porque el código Pig debe estar libre de errores
(un pequeño truco: si parece que el script no tiene en apariencia ningún error, probar a
introducir un retorno de carro después de la última línea).
Captura 4: Plugins de Pig y Hadoop instalados en Eclipse 3.5
1.7
Interactuando con el HDFS
Existen dos maneras principales de interactuar con el HDFS teniendo
correctamente configurado el entorno de trabajo.
1.7.1 Usando la línea de comandos
Un programa MapReduce un poco complejo requerirá de información externa
para procesar: archivos de log, resultados de análisis de webs, etc. Pero antes de poder
utilizar esta información, hay que cargarla en el sistema de ficheros distribuido. Para
cargar información en el HDFS de la máquina virtual, existen varias opciones, entre
ellas:
1. Hacer un scp de los archivos locales a la máquina virtual y luego utilizar el
comando bin/hadoop fs –put... para subirlos al HDFS. Para esto, si se
Instalación del Software
Página | 13
está bajo un entorno Windows, se puede utilizar Cygwin o WinSCP; bajo
entornos Unix este comando ya es nativo.
2. Sacar la información directamente de la máquina local a través de un comando
put leyendo de la entrada estándar stdin.
3. Instalar las herramientas Hadoop en la máquina anfitrión y configurarla para que
se comunique directamente con la máquina cliente. Para ello, se necesita copiar
a un directorio de la máquina local la carpeta hadoop 0.20.1/ incluida en
el directorio “resources” del DVD. Después de esto, se pueden personalizar los
distintos ficheros de configuración (presentes en la carpeta conf/) para utilizar
la máquina virtual como el sistema de ficheros distribuido por defecto. Si
después se ejecutase el comando bin/hadoop fs –put en la máquina
local, interactuarían con el HDFS servido por la máquina virtual.
1.7.2 Usando el plugin MapReduce para Eclipse
Una forma más simple de manipular ficheros y directorios del HDFS es hacerlo
a través del plugin de Eclipse. En el visor de localizaciones de DFS (DFS location
viewer) de Eclipse se muestra el contenido del sistema de ficheros, pudiendo hacer click
con el botón derecho del ratón sobre cualquier parte del mismo para desplegar todas las
acciones contextuales: crear nuevos subdirectorios, subir ficheros individuales o
subdirectorios enteros, o descargar todos los ficheros al disco local.
Por ejemplo, si el directorio /user/hadoop-user no existe, se debe crear
primero, ya que será nuestro espacio de trabajo en el HDFS; para ello, basta con pulsar
con el botón derecho del ratón sobre el directorio raíz, especificar “Create new
directory” y darle un nombre (user, en este caso). A continuación, para poder ver el
nuevo directorio, hace falta pulsar el botón derecho del ratón y pulsar en la opción
“Refresh”. Este procedimiento se repetirá hasta conseguir la estructura de directorios
deseada.
1.8
Lanzando un programa de prueba
En los primeros capítulos de la memoria principal ya se ha introducido el
modelo de programación MapReduce, así como los elementos constituyentes del mismo.
Página | 14
Consideraciones Técnicas
En esta sección se va a ilustrar la ejecución de un problema muy simple sobre la
máquina virtual que se ha montado.
El programa en cuestión es una utilidad de conteo de palabras. Leerá el
contenido de los ficheros que se hayan subido previamente al HDFS y determinará
cuántas veces aparece cada palabra en los ficheros.
Si todavía no se ha hecho, arránquese la máquina virtual, Eclipse y cámbiese a la
perspectiva MapReduce
1.8.1 Creación del Proyecto
En el menú principal de Eclipse, pulsar “File-->New...--> Project” y elegir
“MapReduce Project” de la lista disponible. A continuación, pulsar en “Next”.
A continuación se elegirá un nombre para el proyecto. Cualquier nombre es
bueno, como por ejemplo “WordCount”. También se necesita especificar la ruta de
instalación de la librería de Hadoop. Esta ruta debería ser donde se realizó la copia del
directorio hadoop-0.20.1/ del DVD. Ya que de momento no está configurada esta
parte de Eclipse, se procederá a hacerlo ahora pulsando en la opción “Configure
Hadoop install directory...” y eligiendo la ruta al archivo hadoop-0.20.1.jar que
está incluido en el directorio anterior.
El hecho de crear un proyecto del tipo MapReduce y no hacerlo como uno
genérico Java hace que Eclipse añada automáticamente los ficheros jar necesarios a la
ruta de construcción del proyecto. En cambio si se crease como un proyecto Java,
deberíamos añadir el archivo hadoop-0.20.1.jar y sus dependencias de manera
manual.
Al completar los pasos, se debe hacer click en “Finalizar”.
1.8.2 Creación de los archivos fuente
El programa necesita tres clases para ejecutarse: una map, una reduce y una
driver (o master). La driver básicamente le dice a Hadoop cómo ejecutar el trabajo
MapReduce mientras que las clases map y la reduce trabajan sobre los datos.
Pulsando con el botón derecho del ratón sobre la carpeta de fuentes que se habrá
creado (“src”), se desplegarán una serie de opciones entre las que habrá que elegir
“New-->Others...” Dentro ahora de la carpeta “Map/Reduce” se podrán crear clases
map, reduce y driver. Se recomienda, por tanto, crear tres clases: WordCountMapper,
Instalación del Software
Página | 15
WordCountReducer y WordCount que hereden respectivamente las tres clases padres
anteriores.
El código para cada una de estas clases se muestra en las Capturas 5, 6 y 7.
1.8.3 Lanzando el trabajo contra el HDFS
Una vez se hayan codificado las clases, es la hora de ejecutarlas contra el HDFS.
Si no se ha hecho, es necesario crear un directorio “input” bajo “/user/hadoop-user”,
que será donde se almacenen los ficheros que la aplicación leerá. Hecho esto, en el
explorador de proyectos de Eclipse, hay que hacer click con el botón derecho del ratón
sobre la clase “WordCount.java” que se acaba de crear y elegir la opción “Run As->Run On Hadoop”. A continuación aparecerá una ventana pidiendo elegir una
localización de Hadoop sobre la que ejecutarse. Se deberá elegir la IP de la máquina
virtual que se configuró anteriormente y pulsar el botón “Finish”.
Si todo ha ido bien, y no ha habido errores de compilación ni de ejecución, el
progreso del trabajo MapReduce debería mostrarse en la consola de Eclipse con un
formato parecido al que muestra la Captura 8.
Si ahora a continuación se pulsa con el botón derecho del ratón sobre la
estructura de directorios del HDFS en Eclipse y se elige la acción “Refresh”, se debería
ver un directorio “output” que contendrá un único fichero llamado “part-r-00000”
que es el nombre por defecto de la salida del trabajo. Haciendo doble click en él
podremos visualizarlo directamente en Eclipse. El fichero contendrá, separado por
tabulaciones, dos campos por línea: la palabra en sí y su frecuencia de apariciones en los
ficheros (quizás aparezca una advertencia si el fichero es superior en tamaño a 1 Mb).
Si se desea volver a ejecutar el trabajo, es necesario borrar el directorio “output”
antes, mediante la opción “Delete”, desde el propio explorador de HDFS de Eclipse.
Página | 16
Consideraciones Técnicas
package src;
import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
public class WordCountMapper extends Mapper<Object, Text,
Text, IntWritable> {
private final IntWritable one = new IntWritable(1);
private Text word = new Text();
public void map(Object key, Text value, Context
context) throws IOException,InterruptedException {
String line = value.toString();
StringTokenizer itr = new
StringTokenizer(line.toLowerCase());
while(itr.hasMoreTokens()) {
word.set(itr.nextToken());
context.write(word, one);
}
}
}
Captura 5: Código Java clase WordCountMapper
Instalación del Software
Página | 17
package src;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
public class WordCountReducer extends
Reducer<Text,IntWritable,Text,IntWritable>
{
private IntWritable result = new IntWritable();
public void reduce(Text key, Iterable<IntWritable>
values, Context context)
throws IOException, InterruptedException {
int sum = 0;
for (IntWritable val : values) {
sum += val.get();
}
result.set(sum);
context.write(key, result);
}
}
Captura 6: Código Java clase WordCountReducer
Página | 18
Consideraciones Técnicas
package src;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import
org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import
org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
public class WordCount {
public static void main(String[] args) throws Exception {
Configuration conf = new Configuration();
FileSystem fs = FileSystem.get(conf);
Job job = new Job(conf, "new word count");
job.setJarByClass(NewWordCount.class);
job.setMapperClass(WordMapper.class);
job.setCombinerClass(WordReducer.class);
job.setReducerClass(WordReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
FileInputFormat.addInputPath(job, new Path("input"));
Path outputPath = new Path("output");
try {
if (fs.exists(outputPath)) {
//remove the directory first
fs.delete(outputPath,true);
}
}
catch (IOException ioe) {
System.err.println("Error deleting output dir");
System.exit(1);
}
FileOutputFormat.setOutputPath(job, outputPath);
System.exit(job.waitForCompletion(true) ? 0 : 1);
}
}
Captura 7: Código Java clase WordCount
Manual de Usuario del proyecto MRPGA
08/06/25 12:14:22 INFO
input paths to process
08/06/25 12:14:23 INFO
job_200806250515_0002
08/06/25 12:14:24 INFO
0%
08/06/25 12:14:31 INFO
0%
08/06/25 12:14:33 INFO
0%
08/06/25 12:14:42 INFO
100%
08/06/25 12:14:43 INFO
job_200806250515_0002
08/06/25 12:14:43 INFO
08/06/25 12:14:43 INFO
08/06/25 12:14:43 INFO
tasks=4
08/06/25 12:14:43 INFO
reduce tasks=1
08/06/25 12:14:43 INFO
map tasks=4
08/06/25 12:14:43 INFO
Framework
08/06/25 12:14:43 INFO
records=211
08/06/25 12:14:43 INFO
records=1609
08/06/25 12:14:43 INFO
bytes=11627
08/06/25 12:14:43 INFO
bytes=16918
08/06/25 12:14:43 INFO
input records=1609
08/06/25 12:14:43 INFO
output records=682
08/06/25 12:14:43 INFO
groups=568
08/06/25 12:14:43 INFO
records=682
08/06/25 12:14:43 INFO
output records=568
Página | 19
mapred.FileInputFormat: Total
: 3
mapred.JobClient: Running job:
mapred.JobClient:
map 0% reduce
mapred.JobClient:
map 50% reduce
mapred.JobClient:
map 100% reduce
mapred.JobClient:
map 100% reduce
mapred.JobClient: Job complete:
mapred.JobClient: Counters: 12
mapred.JobClient:
Job Counters
mapred.JobClient:
Launched map
mapred.JobClient:
Launched
mapred.JobClient:
Data-local
mapred.JobClient:
Map-Reduce
mapred.JobClient:
Map input
mapred.JobClient:
Map output
mapred.JobClient:
Map input
mapred.JobClient:
Map output
mapred.JobClient:
Combine
mapred.JobClient:
Combine
mapred.JobClient:
Reduce input
mapred.JobClient:
Reduce input
mapred.JobClient:
Reduce
Captura 8: Resultado ejecución trabajo MapReduce WordCount
2. Manual de Usuario del proyecto MRPGA
Una vez configurado el entorno Eclipse y lanzado el problema “WordCount” de
forma exitosa para comprobar la correcta conexión con el HDFS (véase la sección
Página | 20
Consideraciones Técnicas
anterior), el siguiente paso será montar la aplicación implementada para este proyecto.
Para ello, una vez arrancado Eclipse, nos dirigiremos al menú “File -->New...->Project...-->Java Project” para indicar que queremos crear un nuevo proyecto Java
con el código fuente extraído de la carpeta “src/distribuido” del DVD, con el nombre
que deseemos (por ejemplo MRPGA).
Hecho esto, tendremos que configurar el “build path” del proyecto. Para ello,
haremos click con el botón derecho sobre el proyecto recién creado y nos iremos al
apartado “Properties...”. Dentro de la pantalla que se acaba de abrir, nos deberemos
dirigir a dos sub-menús de gran importancia:

Java Build Path: Aquí, dentro de la pestaña “Libraries”, indicaremos todas las
librerías –aparte del JRE que incluye Eclipse por defecto- que necesitamos para
compilar la aplicación. En concreto, pulsaremos sobre el botón “Add External
JARs...” y escogeremos añadir todo el contenido de la carpeta “lib” del DVD. La
Captura 9 muestra dicho sub-menú.
Captura 9: Menú Java Build Path en Eclipse 3.5

Run/Debug Settings: Si todavía no existe ninguna, podremos crear una nueva
configuración de ejecución, indicando que la clase principal es la clase “Cliente”
del paquete “common” y, dentro de la pestaña “Arguments”, especificar los
Manual de Usuario del proyecto MRPGA
Página | 21
distintos parámetros con los que se lanzará la aplicación, tal y como se aprecia
en la Captura 10. El número y explicación de cada uno de ellos viene aclarado
en el fichero README.txt del DVD. Finalizada la configuración, bastará con
aceptar los cambios para que queden guardados.
Captura 10: Edición de parámetros de la aplicación en Eclipse 3.5
A continuación, dentro del paquete “problems” de la carpeta “src” que
deberemos estar viendo en nuestro nuevo proyecto, se han incluido dos ficheros de
ejemplo correspondientes a dos posibles implementaciones de las clases map y reduce
del problema de la “frase objetivo”. Estos ficheros pueden ser tomados como referencia
para posibles futuras implementaciones.
El DVD también contiene una carpeta llamada “config” que contiene varios
ficheros XML de configuración específicos de los problemas de la “frase objetivo”
(TargetPhrase.xml), “OneMAX” y “P-Picos”. Esta carpeta también tendrá que formar
parte del proyecto en Eclipse situándola al mismo nivel que la carpeta “src” (copiándola
entera o haciendo click con el botón derecho sobre el nombre del proyecto y creando
una nueva carpeta con el mismo nombre). Será en esta carpeta donde almacenaremos
los distintos ficheros XML de configuración de parámetros específicos del problema a
resolver. Este fichero también puede servir de modelo para los siguientes.
Página | 22
Consideraciones Técnicas
Para finalizar y suponiendo que ya tenemos correctamente configurado los
parámetros necesarios de Hadoop y Pig –tal y como se explica en el apartado anterior-,
solo resta pulsar con el botón derecho del ratón sobre la clase “Cliente.java” y
lanzar la aplicación con “Run As --> Run on Hadoop”. Inmediatamente empezará a
aparecer el traceback de depuración del HDFS en la consola de Eclipse, hasta que se
cumpla el criterio de terminación de la aplicación (véase Captura 11).
Captura 11: Resultados de ejecución del proyecto MRPGA en Eclipse 3.5
Otra opción que tenemos es generar un fichero JAR para poder lanzar la
aplicación directamente desde el clúster con el comando de ejecución de Hadoop:
hadoop. Para ello, copiaremos la carpeta “lib” y el fichero “build.xml” del DVD y
los pegaremos en el directorio donde hayamos generado el proyecto. A continuación,
abriríamos una consola, nos situaríamos en el anterior directorio y ejecutaríamos el
comando ant compile jar para compilar el código fuente y generar el fichero
JAR. Con el fichero generado (“mrpga_cluster.jar”), deberemos copiarlo a
algún directorio sobre el que tengamos permisos adecuados y -tras asegurarnos que
el directorio raiz de Hadoop y de Pig está en nuestro PATH- lanzarlo con el comando
hadoop
jar
mrpga_cluster.jar
<lista_argumentos>.
Como
se
comentó anteriormente, la lista de argumentos viene detallada tanto en la
Manual de Programador del proyecto MRPGA
Página | 23
documentación Javadoc de la clase “Cliente.java” proporcionada en el directorio
“docs” como en el fichero README.txt, ambos incluidos en el DVD.
3. Manual de Programador del proyecto MRPGA
Las clases proporcionadas en el DVD como ejemplo pueden servir como base
para futuras implementaciones de nuevos problemas, pero obviamente pueden ser
mejoradas y ampliadas. Desde el punto de vista del programador que quiere
implementar su propio problema de AGs básicos, existen varios aspectos a destacar:
1. Lo primero que debería hacer el programador es construir un fichero XML
dentro del directorio “config” del proyecto que siguiese el esquema del
proporcionado como ejemplo, recordando por una parte que puede añadir todas
las etiquetas (parámetros) que necesite para resolver su problema, pero
respetando siempre la restricción de que es obligatorio que contenga por lo
menos dos: “<targetFitness>” y “<bestFitness>”. La clase Cliente se ocupará de
generar un fichero para que las clases map y reduce puedan tener accesibles
estos parámetros durante la ejecución del trabajo MapReduce.
2. A
continuación
debería
tomar
como
base
la
clase
“TargetPhraseMapper.java” y codificar la suya propia, respetando la
firma de los métodos. En la primera de ellas, tendrá la libertad de redefinir a su
gusto el método de evaluación de fitness de los individuos de su problema,
teniendo a su disposición tanto los parámetros específicos del problema
(parámetro “problemParams”) como los generales que introdujo desde línea de
comandos (“generalParams”). Asimismo, podrá realizar la inicialización de
estructuras o variables que necesite en el método problemSetup(...),
teniendo en cuenta que este método será llamado desde el método setup(...)
de un nodo map (el cual se ejecuta una única vez, a diferencia del método
map(...)). Por último, podrá apoyarse en tantos métodos privados como
necesite
3. En la clase reduce del problema que quiera implementar el programador tendrá
libertad de elegir la codificación que desee de los métodos de cruce y mutación
de individuos. Tal y como se comentó en la sección 3 del Capítulo 3 de la
memoria, existen muchas implementaciones distintas de ambos métodos. En la
Página | 24
Consideraciones Técnicas
clase ejemplo proporcionada “TargetPhraseReducer.java” se utilizó un
cruce de doble punto y una mutación probabilística –lo cual no quiere decir que
necesariamente sean las mejores decisiones a adoptar.
4. El programador debería asegurarse de contar con los permisos adecuados para el
directorio de Entrada/Salida temporal que se crea durante la ejecución del
sistema (el cual se indica también como parámetro por consola).
5. Como ya se dijo en el Capítulo 4 de la memoria del proyecto, las clases
pertenecientes al paquete “common” son las que componen el núcleo principal
de la aplicación. Si por ejemplo, el usuario desease implementar un AG que se
alejase de la estructura explicada en la sección 3 del Capítulo 3 de la memoria
principal,
debería
modificar
las
clases
“Coordinador.java”
y
“MRPGAReducer.java” que son las que encapsulan el comportamiento
fundamental del AG (una itera y filtra los resultados y la otra genera poblaciones
mediante cruces, torneos, reducciones y mutaciones).
6. La clase “RandomDoublePartitioner.java” es una implementación
concreta de la clase “Partitioner” de Hadoop. Con ella se intenta conseguir un
reparto uniforme de individuos entre los distintos nodos map y reduce de un
trabajo MapReduce, sin embargo, su método principal getPartition(...)
acepta diferentes implementaciones. Esta clase es llamada desde el método
main(...) de la clase “MRPGAMaster.java”.
7. La implementación actual soporta codificación de individuos en formato binario
y alfanumérico, ya que son las dos representaciones más utilizadas. Si el usuario
quisiese
implementar
alguna
“CustomChromosome.java”
más,
sólo
que
debería
extendiese
crear
una
la
clase
clase
“Chromosome.java” dentro del paquete “common”.
8. Las posibilidades que ofrece el script Pig Latin embebido en el código Java de la
clase “PigFunction.java” es limitado y que esta herramienta ofrece
capacidades de análisis mucho mayores que quizás sea interesante explotar de
cara al futuro. La clase “Coordinador.java” llama a esta clase para
preparar los individuos de cara a la siguiente iteración.
9. Para construir la versión secuencial del sistema (incluida dentro del directorio
“src/secuencial”, montaríamos un proyecto Java normal en Eclipse pasándole
los parámetros adecuados) y descomentaríamos en la clase “Main.java” un
Manual de Programador del proyecto MRPGA
Página | 25
conjunto de parámetros u otro (ya están indicados) en función del problema que
quisiésemos ejecutar.
10. Existen varias anotaciones a lo largo del código, muchas de ellas son simples
comentarios,
pero
otras
parseXMLFile(...)
(tales
de
la
como
clase
la
presente
Cliente
en
o
en
el
método
la
clase
“MRPGAMaster.java”) deben ser tenidas en cuenta, ya que son
modificaciones necesarias para poder ejecutar la aplicación tanto empaquetada
en un JAR como directamente desde Eclipse.
A mayores de estos puntos y teniendo en cuenta la dificultad de depurar una
aplicación distribuida de manera remota, es importante recordar que Hadoop
proporciona varias interfaces web en las que se pueden consultar el estado y los
distintos resultados de nuestros programas (para más información, consúltese la web
principal del proyecto Hadoop: http://hadoop.apache.org/). De entre ellas, destacaremos
la siguiente:
http://<ip_máquina_hadoop>:50070/logs/userlogs
Bajo esta URL se encuentran los distintos trabajos MapReduce que vamos
ejecutando, divididos en tareas map (con nombres del estilo “nombre_tarea_m_000x”) y
reduce (“nombre_tarea_r_000x”). Cada una de estas tareas contiene tres directorios:
stderr, syslog y stdout que contendrán los distintos mensajes de error e informativos que
podamos emplear para facilitar la depuración de nuestra aplicación.