Documentos de Académico
Documentos de Profesional
Documentos de Cultura
FACULTAD DE INFORMÁTICA
Departamento de Electrónica y Sistemas
-.Consideraciones técnicas.-
Índice general
CONSIDERACIONES TÉCNICAS ____________________________________________________1
Í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.1 Prerrequisitos
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 Consideraciones Técnicas
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
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
hadoop-user@hadoop-desk:~$ cd hadoop
hadoop-user@hadoop-desk:~/hadoop$ bin/hadoop jar hadoop-
0.18.0-examples.jar pi 10 1000000
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.
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.
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.
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 Página | 11
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
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.
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
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;
package src;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
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;
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 Página | 19
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ú.
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.
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
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
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 (tales como la presente en el método
parseXMLFile(...) de la clase Cliente o en 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.