YARN y ejecución de trabajos

Qué resuelve YARN

HDFS guarda los datos. YARN (Yet Another Resource Negotiator) asigna memoria y CPU a los trabajos que los procesan.

Componente	Función
ResourceManager	Gestiona recursos globales y planificación.
NodeManager	Informa y administra recursos de cada nodo.
ApplicationMaster	Coordina la ejecución de una aplicación concreta.
Contenedor YARN	Memoria y CPU asignadas a un proceso del trabajo.

Del envío al resultado

El diagrama sigue de arriba abajo la ejecución de un contador de palabras (wordcount). Las flechas continuas muestran mensajes de control y las discontinuas indican el sentido en que viajan los datos.

Cada trabajador es un contenedor Docker que aloja un NodeManager. Ese NodeManager puede iniciar varios contenedores YARN para ejecutar las tareas del trabajo.

Configuración y arranque

Vamos a levantar un clúster Hadoop multinodo con Docker Compose. Tendrá cuatro contenedores: un nodo principal (master), que aloja el NameNode y el ResourceManager, y tres trabajadores (datanode1, datanode2 y datanode3). Cada trabajador ejecuta un DataNode para HDFS y un NodeManager para YARN. Primero comprobaremos por terminal y desde el navegador que los tres trabajadores están registrados en ambos sistemas. Después seguiremos un trabajo sencillo de principio a fin y usaremos el mismo clúster para observar qué ocurre al incorporar o detener un trabajador.

1. Preparar el anfitrión

Si el laboratorio anterior sigue en marcha, detenlo con la parada del bloque 02. Así liberas los puertos compartidos y conservas sus datos. El clúster nuevo tiene su propio HDFS.

Necesitas Make, Git y Docker con Compose v2. Si usas Docker Desktop, asigna al menos 4 GB de memoria. El clúster completo ocupa unos 1,9 GB en reposo y 2,7 GB al ejecutar un trabajo. Si tu equipo tiene poca memoria, puedes usar el modo mini.

Requisitos en Windows 11

1. Instala WSL2 con Ubuntu. Si aún no tienes Ubuntu en WSL, ejecuta esta orden en PowerShell como administrador y reinicia el equipo si se solicita. La opción -d Ubuntu selecciona Ubuntu explícitamente.

   wsl --install -d Ubuntu

   En PowerShell, ejecuta wsl -l -v y comprueba que Ubuntu aparece con VERSION 2. Si ya lo tenías instalado con la versión 1, conviértelo con wsl --set-version Ubuntu 2. Instalación de WSL en Microsoft Learn

2. Instala y abre Docker Desktop. En Settings → Resources → WSL Integration, activa la integración con tu distribución Ubuntu.

3. Abre el menú Inicio de Windows, escribe Ubuntu y selecciona la aplicación Ubuntu. También puedes abrirla desde PowerShell con wsl -d Ubuntu. Si es la primera vez que la abres, Ubuntu te pedirá un nombre de usuario y una contraseña para Linux.

   En la terminal de Ubuntu, instala Make y Git. Comprueba que puedes acceder a Docker y a Compose desde esa misma terminal.

   sudo apt update
   sudo apt install make git
   make --version
   docker info
   docker compose version

Desde este punto, en Windows la terminal del anfitrión es la de Ubuntu en WSL. Clona el repositorio bajo tu carpeta personal de Ubuntu (~, dentro de /home/) y ejecuta allí las órdenes make. Las interfaces web se abren desde el navegador de Windows en localhost. Uso en Windows 11 en el README

Obtener el repositorio

En la terminal del anfitrión, clona el repositorio y entra en modulo01/.

git clone https://github.com/josepgarcia/BigDataAplicadoLab_2627.git
cd BigDataAplicadoLab_2627/modulo01

Si ya tienes el repositorio, actualízalo con git pull desde su raíz y entra en modulo01/. Ejecuta desde esa carpeta las órdenes de Make y de Compose. README del laboratorio

2. Arrancar el clúster

En el anfitrión, desde modulo01/, levanta el clúster completo.

make up

make up usa la configuración de hadoop/compose.yaml para arrancar master y los tres trabajadores. Espera a que estén listos y muestra las URL de HDFS y YARN. Si cambias la receta de la imagen y necesitas reconstruirla, ejecuta make build antes de make up.

Modo mini opcional

Para ejecutar wordcount y Hadoop Streaming en equipos con poca memoria, usa el modo mini. Desde modulo01/ en el anfitrión, ejecuta:

make up-mini

El atajo deja activos master y datanode1 y conserva los volúmenes de los demás trabajadores. HDFS guarda una copia por defecto y el consumo ronda 1 GB en reposo y 1,4 GB al ejecutar un trabajo. Para volver al clúster completo, ejecuta make up.

Los dos modos comparten los volúmenes. Los archivos creados con réplica 3 pueden aparecer como under-replicated (con menos copias vivas de las solicitadas) en el mini. Los archivos creados en el mini conservan su objetivo de réplica 1 al volver al modo completo.

En el modo mini puedes seguir la ejecución de las tareas en YARN. Para observar tres réplicas, el reparto de bloques y tareas entre trabajadores o la lectura tras detener un DataNode, necesitas el modo completo.

3. Entrar en master y comprobar el clúster

Desde el anfitrión, abre una shell en master con la cuenta hadoop.

make shell

Por terminal, ejecuta estas órdenes dentro de master. En modo completo, espera tres trabajadores.

hdfs dfsadmin -report
yarn node -list

• HDFS. En la salida de hdfs dfsadmin -report, busca Live datanodes (3).
• YARN. En la salida de yarn node -list, comprueba que datanode1, datanode2 y datanode3 aparecen en estado RUNNING.

Desde el navegador del anfitrión, comprueba los mismos trabajadores.

• HDFS. Abre la interfaz del NameNode y entra en Datanodes. Los tres deben aparecer en la lista de nodos vivos (Live Nodes). Interfaz de HDFS
• YARN. Entra en Cluster → Nodes y comprueba que los tres aparecen con estado RUNNING. Nodos de YARN

En modo mini, el informe de HDFS muestra Live datanodes (1), y datanode1 es el único trabajador en estado RUNNING en YARN. Las interfaces web deben mostrar ese mismo trabajador vivo.

Si quieres hacer una comprobación rápida desde el anfitrión, make test comprueba los nodos vivos, ejecuta wordcount en YARN y lanza un trabajo de Hadoop Streaming con Python. Lee el número esperado de trabajadores de dfs.replication. En modo completo empieza con 🧪 1/3 HDFS y YARN: nodos vivos (esperados: 3). En modo mini indica esperados: 1.

Continúa cuando estén disponibles los trabajadores del modo que has arrancado.

Repaso opcional. En otra terminal del anfitrión, desde modulo01/, copia los ficheros de mapreduce/ a /home/hadoop/trabajo/ dentro de master. Entre ellos está ventas.csv. El contador de palabras tendrá su propia entrada.

make copiar-mapreduce

Si has copiado el CSV, termina el repaso subiéndolo a HDFS desde la shell de master.

hdfs dfs -mkdir -p /datos/m01-03
hdfs dfs -put /home/hadoop/trabajo/ventas.csv /datos/m01-03/
hdfs dfs -ls /datos/m01-03

Mantén abierta la shell de master para consultar los XML y ejecutar wordcount.

Ficheros de configuración

Dentro de master, los XML están en /opt/hadoop/etc/hadoop/. Compose los monta en solo lectura desde modulo01/hadoop/conf/ del repositorio. Para ver los dos que configuran YARN y MapReduce, ejecuta como hadoop:

cat /opt/hadoop/etc/hadoop/mapred-site.xml
cat /opt/hadoop/etc/hadoop/yarn-site.xml

mapred-site.xml indica que MapReduce se ejecuta en YARN y dónde están sus bibliotecas. yarn-site.xml identifica el ResourceManager y activa el shuffle, que permite a las tareas reduce recoger los resultados de las tareas map.

mapred-site.xml

<configuration>
  <property>
    <name>mapreduce.framework.name</name>
    <value>yarn</value>
  </property>
  <property>
    <name>yarn.app.mapreduce.am.env</name>
    <value>HADOOP_MAPRED_HOME=/opt/hadoop</value>
  </property>
  <property>
    <name>mapreduce.map.env</name>
    <value>HADOOP_MAPRED_HOME=/opt/hadoop</value>
  </property>
  <property>
    <name>mapreduce.reduce.env</name>
    <value>HADOOP_MAPRED_HOME=/opt/hadoop</value>
  </property>
  <property>
    <name>yarn.app.mapreduce.am.resource.mb</name>
    <value>512</value>
  </property>
  <property>
    <name>yarn.app.mapreduce.am.command-opts</name>
    <value>-Xmx384m</value>
  </property>
  <property>
    <name>mapreduce.map.memory.mb</name>
    <value>512</value>
  </property>
  <property>
    <name>mapreduce.map.java.opts</name>
    <value>-Xmx384m</value>
  </property>
  <property>
    <name>mapreduce.reduce.memory.mb</name>
    <value>512</value>
  </property>
  <property>
    <name>mapreduce.reduce.java.opts</name>
    <value>-Xmx384m</value>
  </property>
</configuration>

yarn-site.xml

<configuration>
  <property>
    <name>yarn.resourcemanager.hostname</name>
    <value>master</value>
  </property>
  <property>
    <name>yarn.nodemanager.aux-services</name>
    <value>mapreduce_shuffle</value>
  </property>
  <property>
    <name>yarn.nodemanager.aux-services.mapreduce_shuffle.class</name>
    <value>org.apache.hadoop.mapred.ShuffleHandler</value>
  </property>
  <property>
    <name>yarn.nodemanager.resource.memory-mb</name>
    <value>1536</value>
  </property>
  <property>
    <name>yarn.nodemanager.resource.cpu-vcores</name>
    <value>2</value>
  </property>
  <property>
    <name>yarn.scheduler.minimum-allocation-mb</name>
    <value>256</value>
  </property>
  <property>
    <name>yarn.scheduler.maximum-allocation-mb</name>
    <value>1536</value>
  </property>
  <property>
    <name>yarn.nodemanager.vmem-check-enabled</name>
    <value>false</value>
  </property>
</configuration>

HADOOP_MAPRED_HOME=/opt/hadoop indica dónde encontrar MapReduce al arrancar el ApplicationMaster y las tareas map y reduce. El nombre master permite a los trabajadores localizar el ResourceManager en la red de Compose.

Cada NodeManager anuncia a YARN 1536 MiB y 2 núcleos virtuales. En este laboratorio está desactivada la comprobación de memoria virtual. MapReduce solicita un contenedor YARN de 512 MiB para el ApplicationMaster y para cada tarea map y reduce. La opción -Xmx384m limita a 384 MiB la memoria dinámica de cada JVM y deja margen para otros usos de memoria del contenedor.

Qué puedes consultar en la web de YARN

La interfaz del ResourceManager se abre en el navegador del anfitrión. Docker Compose publica el puerto 8088 en 127.0.0.1. Web de YARN

• Nodes. Muestra los trabajadores registrados, su estado y cuántos contenedores YARN ejecuta cada uno. Si el clúster está en reposo, es normal ver cero contenedores en ejecución. Los enlaces de cada NodeManager usan el puerto interno 8042, accesible desde la red del laboratorio.
• Applications. Muestra los trabajos en espera, en ejecución y terminados. Puedes filtrar por estado y abrir el detalle de un trabajo pulsando su identificador.
• About → Scheduler Metrics. Busca Minimum Allocation y Maximum Allocation. Son los límites de recursos que el planificador puede asignar a un contenedor YARN. Memory Total, en cambio, es la memoria que los trabajadores anuncian en conjunto a YARN.

En este laboratorio, el mínimo es 256 MiB y el máximo es 1536 MiB por contenedor YARN. Memory Total suma 4608 MiB (4,5 GiB) con tres trabajadores y 1536 MiB (1,5 GiB) con uno. Es la capacidad anunciada a YARN. El consumo real de Docker se mide por separado. Los límites de este curso se han ajustado para trabajar en equipos con menos memoria.

Consulta opcional. La captura del curso anterior muestra un clúster de un solo trabajador. Los recuadros marcan un mínimo de 1024 MiB y un máximo de 8192 MiB por contenedor. Localiza esos mismos campos en tu clúster y lee los valores que muestra tu configuración.

M01-YARN-01. Seguir un contador de palabras

Vamos a ejecutar wordcount, un programa de ejemplo que ya viene con Hadoop. Prepararemos la entrada en HDFS, enviaremos el trabajo a YARN y comprobaremos el resultado en HDFS. Usa la shell de master que ya tienes abierta como hadoop.

Preparar la entrada

Crea un fichero local con tres palabras y súbelo al directorio HDFS de entrada. Comprueba que se puede leer desde HDFS.

hdfs dfs -mkdir -p /datos/ejemplos/entrada
printf 'hola datos hola\n' > /tmp/texto.txt
hdfs dfs -put -f /tmp/texto.txt /datos/ejemplos/entrada/texto.txt
hdfs dfs -cat /datos/ejemplos/entrada/texto.txt

Enviar el trabajo y leer el resultado

La ruta HDFS de salida debe ser nueva. Si ya existe /datos/ejemplos/salida-wordcount de un ensayo anterior, elige otro nombre, como salida-wordcount-02, y úsalo tanto al lanzar el trabajo como al leer el resultado.

hadoop jar /opt/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.1.jar wordcount \
  /datos/ejemplos/entrada /datos/ejemplos/salida-wordcount

El JAR contiene el programa. Los dos últimos argumentos indican dónde leer la entrada y dónde escribir la salida. Cuando aparezca Submitted application, anota el identificador application_… para localizar tu trabajo. Al terminar, busca los contadores Launched map tasks y Launched reduce tasks. En esta muestra normalmente se ejecuta una tarea de cada tipo.

hdfs dfs -ls /datos/ejemplos/salida-wordcount
hdfs dfs -cat '/datos/ejemplos/salida-wordcount/part-*'

En el listado debe aparecer _SUCCESS. En los ficheros cuyo nombre empieza por part- encontrarás los recuentos datos 1 y hola 2.

Ver el trabajo en el navegador

1. Desde el navegador del anfitrión, abre Applications en YARN. Busca word count en la columna Name. Si ya hay varias ejecuciones, usa el identificador application_… que aparece junto a Submitted application en la terminal.
2. Haz clic en el identificador de la columna ID. En el detalle de una ejecución correcta, YarnApplicationState muestra FINISHED y FinalStatus Reported by AM muestra SUCCEEDED. El resultado del conteo se consulta en HDFS con el hdfs dfs -cat del ejemplo.

Consultar el estado y diagnosticar un fallo

Ya has visto el estado en el navegador. Consulta ahora la misma aplicación desde master. Cuando se te pida, pega el identificador que anotaste. Si necesitas localizarlo de nuevo, usa yarn application -list -appStates ALL.

read -r -p 'Identificador de tu aplicación: ' application_id
yarn application -status "$application_id"

Lo que ves en YARN	Qué comprobar
ACCEPTED durante mucho tiempo	Revisa si los NodeManagers están disponibles y hay recursos para iniciar el trabajo.
RUNNING	Consulta el progreso del trabajo.
FINISHED con resultado SUCCEEDED	Comprueba que la salida existe en HDFS y contiene los recuentos esperados.
FAILED o resultado final FAILED	Lee el diagnóstico. Comprueba, por ejemplo, que la entrada existe y la ruta de salida está libre.
KILLED	Consulta quién o qué canceló la aplicación en el diagnóstico disponible.

Si necesitas más detalle, ejecuta yarn logs -applicationId "$application_id". Si YARN indica que la agregación de registros está desactivada, usa el diagnóstico de -status y los mensajes que dejó hadoop jar en la terminal. Si el fallo ocurre antes de obtener un identificador, empieza por ese mensaje de la terminal.

Evidencia de M01-YARN-01

Entrega un Markdown breve con el identificador de tu aplicación, su estado en YARN y su resultado final, el número de tareas de cada tipo, la ruta HDFS y los recuentos. Explica qué dato de la terminal o de la web te permitió comprobar el resultado o diagnosticar un fallo. Si has trabajado con una salida facilitada, indícalo en la entrega.

M01-HDFS-06. Observar la incorporación de un nodo

Ya has visto que HDFS guarda los datos y YARN ejecuta el trabajo. Ahora observarás qué cambia en ambos sistemas al añadir un trabajador. Antes de empezar, predice cuántas copias podrá guardar HDFS con dos DataNodes si el fichero pide tres.

Esta práctica y la siguiente requieren la configuración del modo completo. Si vienes del modo mini, el arranque con la receta base que se indica a continuación recupera la configuración de réplica 3 para los archivos nuevos. Si tu equipo solo admite el mini, sigue la demostración docente y analiza sus informes.

Usa dos terminales. Si sigues dentro de master, sal con exit. En la terminal del anfitrión, desde modulo01/, detén el clúster y arráncalo con dos trabajadores. make down conserva los volúmenes.

make down
docker compose -f hadoop/compose.yaml up -d --wait master datanode1 datanode2

En una segunda terminal, también desde modulo01/, ejecuta make shell para entrar en master como hadoop. Deja esta sesión abierta durante las dos prácticas. Comprueba que aparecen dos DataNodes vivos y dos NodeManagers en RUNNING.

hdfs dfsadmin -report
yarn node -list

Con los dos trabajadores disponibles, prepara el fichero de prueba y consulta las ubicaciones de sus bloques.

printf 'Documento con tres replicas solicitadas.\n' > /tmp/replicas.txt
hdfs dfs -mkdir -p /datos/replicacion
hdfs dfs -put -f /tmp/replicas.txt /datos/replicacion/replicas.txt
hdfs fsck /datos/replicacion/replicas.txt -files -blocks -locations

Compara tu predicción con fsck. replication indica el objetivo de tres copias y Live_repl indica las copias vivas. Con dos DataNodes el fichero puede seguir disponible aunque falte una réplica.

En la terminal del anfitrión, vuelve a levantar el clúster completo para incorporar el tercer trabajador.

make up

Vuelve a la terminal que sigue dentro de master y comprueba que ahora aparecen tres DataNodes vivos y tres NodeManagers en RUNNING.

hdfs dfsadmin -report
yarn node -list

Cuando estén los tres DataNodes, espera a que el fichero alcance tres réplicas y verifica sus ubicaciones.

hdfs dfs -setrep -w 3 /datos/replicacion/replicas.txt
hdfs fsck /datos/replicacion/replicas.txt -files -blocks -locations

-setrep 3 solicita tres copias; -w mantiene el comando esperando a que se alcance ese objetivo. Se utiliza aquí porque ya has comprobado que existen tres DataNodes. Si un trabajador no está disponible, interrumpe la espera con Ctrl+C y diagnostica el nodo: no cambies los metadatos internos para forzar el resultado.

Entrega los informes antes/después y explica qué cambió en el espacio de nombres, los bloques y los recursos de ejecución. La incorporación de un DataNode no cambia el contenido lógico del archivo. En este laboratorio los tres volúmenes pueden compartir el mismo disco físico: sumar la capacidad anunciada por los DataNodes no equivale a disponer de tres discos independientes ni prueba un incremento real de capacidad del portátil.

M01-HDFS-07. Leer con un DataNode detenido

En la práctica anterior añadiste un trabajador y comprobaste que HDFS pudo guardar la tercera copia. Ahora vas a comprobar si el fichero sigue siendo legible al detener un trabajador.

Usa las mismas dos terminales. Dentro de master, confirma que el fichero de la práctica anterior tiene tres ubicaciones vivas.

hdfs fsck /datos/replicacion/replicas.txt -files -blocks -locations

En el anfitrión, detén datanode2.

docker compose -f hadoop/compose.yaml stop datanode2

Dentro de master, lee el fichero y consulta el estado de sus réplicas.

hdfs dfs -cat /datos/replicacion/replicas.txt
hdfs fsck /datos/replicacion/replicas.txt -files -blocks -locations

En el anfitrión, vuelve a arrancar el nodo.

docker compose -f hadoop/compose.yaml start datanode2

Dentro de master, consulta el informe hasta que vuelvan a aparecer tres DataNodes vivos.

hdfs dfsadmin -report

En el ensayo, justo después de detener datanode2, el cliente intentó leer primero de esa réplica. La espera duró unos 60 segundos y apareció un ConnectTimeoutException. Después el cliente leyó de otra réplica y devolvió el contenido completo. Si te ocurre, deja que termine y anota el tiempo aproximado, el mensaje y el contenido recuperado. El NameNode tarda en declarar muerto un DataNode: inmediatamente después de stop puede conservar todavía información anterior y fsck no mostrar la subreplicación esperada. Registra lo observado y su momento; no inventes un resultado instantáneo. Con solo dos DataNodes operativos no puede reconstruirse una tercera copia en otro nodo hasta que vuelva el tercero.

Entrega el estado inicial, la lectura durante el fallo con la espera y el mensaje que hayas observado, el informe de fsck y la comprobación posterior al retorno. Explica qué protegen las réplicas y por qué esta prueba no demuestra alta disponibilidad del NameNode, recuperación de todos los volúmenes ni disponibilidad cuando se apaga el equipo anfitrión.

Al terminar, ejecuta make down en el anfitrión para detener el clúster y conservar sus datos. El bloque siguiente vuelve a levantar este mismo Compose para programar la transformación.

Conexión con MapReduce

Aquí has ejecutado un MapReduce ya preparado y has seguido su estado en YARN. En el bloque 04 abrirás esa caja: escribirás un mapper y un reducer sencillos, probarás sus resultados en local y usarás el mismo clúster para ejecutarlos con Hadoop Streaming.