Apéndice A — Operar el clúster: encender, comprobar, apagar y diagnosticar

big-data
docker
hdfs
yarn
spark
operacion
Autor/a

Wilder Ramírez Delgado

Fecha de publicación

26 de octubre de 2026

El problema que vas a resolver

Terminaste el laboratorio del cliente Spark un viernes. El lunes reinicias el computador, abres la terminal y quieres seguir con el taller de MapReduce Streaming. ¿Qué enciendes primero? ¿Qué comando usas, docker compose o dc? ¿Cuándo está listo HDFS para recibir un trabajo? ¿De dónde sale el notebook del taller? Y si algo falla, ¿es un error de verdad o el clúster todavía está arrancando?

Las respuestas están repartidas en los laboratorios de HDFS, YARN y el cliente Spark, que explican cómo se construye el clúster. Este apéndice las reúne en un solo lugar para operarlo cada día, con los avisos y errores que aparecieron al ejecutar esos laboratorios.

Ficha En este apéndice
Pregunta ¿Cómo enciendo, compruebo, uso y apago el clúster sin perder datos?
Punto de partida El clúster completo del laboratorio del cliente Spark, en ~/hdfs-docker-lab
Tiempo estimado de lectura 25 minutos; después, para consulta
Nivel Básico
Conocimientos previos recomendados Haber hecho los laboratorios de HDFS, YARN y el cliente Spark; la terminal del capítulo 2
Tecnologías mencionadas Docker y Docker Compose, Hadoop 3.4.1 (HDFS y YARN), Spark 3.5.3, Jupyter Notebook

Objetivos de aprendizaje

Al terminar este apéndice podrás:

  1. Nombrar los ocho contenedores del clúster, qué hace cada uno y qué puertos publica.
  2. Explicar por qué se usa siempre el atajo dc y qué se rompe sin él.
  3. Encender el clúster en orden y reconocer cuándo HDFS y YARN están listos.
  4. Llevar los notebooks de los talleres a Jupyter.
  5. Apagar sin perder datos y leer los códigos de salida de los contenedores.
  6. Diagnosticar los errores conocidos con una tabla de síntoma, causa y arreglo.
  7. Practicar la operación de Spark sobre YARN: enviar, observar, encolar y cancelar aplicaciones.
TipLo que necesitas recordar
Concepto En una línea Dónde se explica
Contenedor e imagen La imagen es la plantilla; el contenedor, el proceso que corre a partir de ella. Capítulo 3
Modo seguro de HDFS Al arrancar, el NameNode no acepta escrituras hasta tener suficientes bloques reportados. HDFS
NodeManager El agente de YARN que lanza contenedores de trabajo en su nodo. YARN
Overlay de Compose Un segundo archivo que se aplica encima del primero y agrega o cambia servicios. Cliente Spark

Todos los comandos de este apéndice se ejecutan en la terminal de Ubuntu (WSL2 o Linux), dentro de ~/hdfs-docker-lab, salvo que se diga otra cosa.

1. El mapa del clúster

El clúster tiene ocho contenedores en un mismo proyecto de Compose llamado hdfs-lab. Siete los crea compose.yaml (HDFS y YARN) y el octavo, spark-client, lo agrega compose.spark.yaml.

Arriba, tu equipo con el navegador y cuatro direcciones: localhost:9870 NameNode, localhost:8088 ResourceManager, 127.0.0.1:8888 Jupyter y localhost:4040 Spark UI. Abajo, tres grupos. HDFS guarda: namenode con el puerto 9870 y datanode1, datanode2 y datanode3. YARN reparte: resourcemanager con el puerto 8088, y nodemanager1 y nodemanager2 con /opt/python. Cliente envía, resaltado: spark-client con Jupyter en 8888 y Spark UI en 4040, el volumen cpython311 compartido con los dos NodeManagers y la carpeta ./notebooks del host.

Los ocho contenedores, sus funciones y los puertos que llegan al navegador.
Contenedor Pieza Qué hace Puerto en tu equipo
namenode HDFS Guarda los metadatos: qué archivos hay y dónde están sus bloques. localhost:9870
datanode1, datanode2, datanode3 HDFS Guardan los bloques, tres copias de cada uno. ninguno
resourcemanager YARN Reparte memoria y CPU entre las aplicaciones. localhost:8088
nodemanager1, nodemanager2 YARN Lanzan los contenedores de trabajo; tienen montado el Python 3.11 del clúster. ninguno
spark-client Cliente Envía trabajos de Spark y MapReduce, y aloja Jupyter. 127.0.0.1:8888 y localhost:4040
NotaVolumen con nombre

Un volumen con nombre es un espacio de disco que Docker administra aparte de los contenedores. Sobrevive cuando un contenedor se detiene o se elimina, y solo se borra si lo pides. El clúster usa cinco: namenode_data y datanode1_data a datanode3_data guardan HDFS, y cpython311 guarda el Python 3.11.10 que comparten spark-client y los NodeManagers. La carpeta ./notebooks no es un volumen: es una carpeta de tu equipo montada en el contenedor.

2. Por qué siempre dc

El clúster se describe con dos archivos de Compose. Si un comando lee solo el primero, Compose cree que los NodeManagers deben quedar como los define compose.yaml, sin el volumen de Python, y los recrea así sin avisar: la salida dice Started como siempre. Todo parece normal hasta que un trabajo de Python falla en los nodos.

compose.yaml, con HDFS y YARN en 7 servicios, y compose.spark.yaml, con spark-client y Python en los NodeManagers, entran a dc, que usa los dos archivos. dc up -d da 8 contenedores con los NodeManagers con /opt/python. Aparte, resaltado, docker compose up -d usa solo compose.yaml y deja los NodeManagers sin /opt/python.

Con los dos archivos, los NodeManagers conservan /opt/python; con uno solo, lo pierden.

Por eso todos los laboratorios desde el cliente Spark usan el atajo dc. Defínelo en cada terminal nueva:

cd ~/hdfs-docker-lab
dc() { docker compose -f compose.yaml -f compose.spark.yaml "$@"; }
dc config --services

Salida esperada: los ocho servicios, uno por línea, en el orden que decida Compose; lo importante es que aparezca spark-client.

namenode
datanode1
datanode2
datanode3
resourcemanager
nodemanager1
nodemanager2
spark-client

Si no quieres definirlo cada vez, agrega la línea dc() { … } al final de ~/.bashrc (o ~/.zshrc si usas zsh). Como el atajo usa rutas relativas, funciona solo dentro de ~/hdfs-docker-lab.

AdvertenciaSi ya usaste docker compose a secas

Si encendiste con docker compose up -d y el taller de MapReduce Streaming falla con Cannot run program "/opt/python/bin/python3": error=2, No such file or directory, los NodeManagers perdieron el Python. Se arregla sin perder datos: dc up -d recrea solo los dos NodeManagers con el volumen. Espera después a que yarn node -list muestre los dos en RUNNING (sección 3).

3. Encender en orden

Encender es una secuencia: cada paso necesita que el anterior haya terminado. Los contenedores arrancan en segundos, pero HDFS y YARN tardan un poco más en estar listos.

Cinco pasos en fila: 1 Docker, docker info responde; 2 dc up -d, 8 contenedores Up; 3 HDFS, resaltado, Safe mode is OFF y 3 DataNodes; 4 YARN, Total Nodes:2 RUNNING; 5 Jupyter, URL con token.

Los cinco pasos de encendido y la señal que confirma cada uno.

Paso 1: Docker

docker info --format '{{.ServerVersion}}'

Si imprime una versión (por ejemplo 29.1.3), Docker está listo. Si responde Cannot connect to the Docker daemon, enciéndelo según cómo lo instalaste:

Instalación Cómo encender Docker
Docker Desktop en Windows Abre Docker Desktop y espera a que diga que el motor está corriendo.
Docker Engine dentro de Ubuntu (instalado con apt) sudo service docker start (o sudo systemctl start docker si tu WSL usa systemd).

Paso 2: los contenedores

Primero confirma que el proyecto existe. docker compose ls muestra solo los proyectos con contenedores corriendo; con el clúster apagado no lo verás. Agrega -a:

docker compose ls -a
dc up -d
dc ps -a

Señal de éxito: hdfs-lab en la lista de proyectos, con estado exited si estaba apagado, y después de dc up -d los ocho contenedores en estado Up. Si dc ps -a muestra un servicio en Exited justo después de encender, mira su registro con dc logs --tail 30 <servicio>.

Paso 3: HDFS fuera del modo seguro

dc exec spark-client /opt/hadoop/bin/hdfs dfsadmin -safemode wait
dc exec spark-client /opt/hadoop/bin/hdfs dfsadmin -report | grep -E 'Live datanodes|Missing blocks'

Salida esperada: Safe mode is OFF en el primer comando y Live datanodes (3): en el segundo, con Missing blocks: 0. El aviso WARNING: log4j.properties is not found que acompaña a cada comando es inofensivo.

Si lanzas estos comandos en los primeros segundos después de dc up -d, puede salir Connection refused: el NameNode todavía no escucha. Espera unos segundos y repite. Es normal, no es un fallo del clúster. Después de un arranque, el modo seguro se extiende unos 30 segundos más aunque ya estén todos los bloques; -safemode wait espera por ti.

Paso 4: YARN con sus dos nodos

dc exec spark-client /opt/hadoop/bin/yarn node -list

Salida esperada: Total Nodes:2, con nodemanager1 y nodemanager2 en estado RUNNING. Si sale Total Nodes:0, los NodeManagers todavía se están registrando: repite en 10 o 20 segundos. Los números de puerto de cada nodo (nodemanager1:35895, por ejemplo) cambian en cada arranque; lo que importa es el nombre y el estado.

Paso 5: Jupyter

Jupyter es un proceso dentro de spark-client, no un servicio de Compose: no arranca solo. Ábrelo en otra terminal (define dc también allí) y déjala abierta:

dc exec spark-client /opt/python/bin/jupyter notebook \
  --ip=0.0.0.0 --port=8888 --no-browser --allow-root \
  --ServerApp.root_dir=/opt/spark/work-dir

En la terminal aparecen varias líneas de registro y una URL de la forma http://127.0.0.1:8888/tree?token=…. Ábrela en el navegador con el token de tu terminal; cada arranque genera uno nuevo. Si la URL dice http://spark-client:8888/…, cambia solo el nombre por 127.0.0.1. En Jupyter, elige siempre el kernel Python del clúster.

4. Las interfaces web

Dirección Qué muestra Cuándo está disponible
http://localhost:9870 NameNode: DataNodes vivos, capacidad, explorador de archivos de HDFS (Utilities → Browse the file system). Con namenode encendido.
http://localhost:8088 ResourceManager: nodos, aplicaciones y su estado (RUNNING, FINISHED, FAILED). Con resourcemanager encendido.
http://127.0.0.1:8888 Jupyter. Solo mientras corre el servidor del paso 5.
http://localhost:4040 Spark UI: trabajos, etapas y tareas de una aplicación Spark. Solo mientras hay una SparkSession abierta en spark-client; desaparece con spark.stop().
NotaPuertos publicados

Un puerto publicado es un puerto del contenedor que Compose conecta con uno de tu equipo, como 127.0.0.1:8088:8088. Solo esos cuatro llegan al navegador. Las páginas de cada NodeManager (puerto 8042), de cada DataNode (9864) y el historial de trabajos MapReduce (19888) existen dentro de la red del clúster, pero no se publican: la página del ResourceManager enlaza a ellas y el enlace no abrirá. Para ver lo que hizo una aplicación, usa yarn logs -applicationId <id> desde spark-client.

5. Llevar los talleres a Jupyter

Los talleres de MapReduce Streaming, Spark con ejemplos y PySpark, y los capítulos de almacenamiento analítico, Spark SQL y DataFrames, ingesta, calidad, optimización, MLlib, Airflow, Iceberg, Kafka, Structured Streaming y seguridad, son notebooks que se ejecutan dentro de spark-client. Jupyter muestra la carpeta /opt/spark/work-dir del contenedor, que es ~/hdfs-docker-lab/notebooks en tu equipo, así que basta con dejar ahí esos archivos.

Descarga talleres-notebooks.zip. Trae taller_streaming.ipynb, taller_spark.ipynb, taller_pyspark.ipynb, taller_almacenamiento.ipynb, taller_spark_sql.ipynb, taller_ingesta.ipynb, taller_calidad.ipynb, taller_optimizacion.ipynb, taller_mllib.ipynb, taller_airflow.ipynb, taller_iceberg.ipynb, taller_kafka.ipynb, taller_streaming_kafka.ipynb y taller_seguridad.ipynb sin salidas, listos para ejecutar, y generar_envios.py, el programa que crea los datos del taller de PySpark y de los capítulos de ingesta y calidad. Trae además taller_databricks.ipynb, del capítulo de la nube, que no se ejecuta en este Jupyter sino en Databricks. El de seguridad necesita además preparar el NameNode (registro de auditoría con compose.seguridad.yaml, la función dcs y los usuarios del caso); los pasos están en su sección «Antes de empezar». Desde WSL, la carpeta Descargas de Windows está en /mnt/c/Users/<tu-usuario>/Downloads/:

cd ~/hdfs-docker-lab
cp /mnt/c/Users/<tu-usuario>/Downloads/talleres-notebooks.zip .
unzip -o talleres-notebooks.zip -d notebooks
ls notebooks

Cambia <tu-usuario> por tu usuario de Windows. Si Ubuntu no tiene unzip, instálalo con sudo apt install -y unzip. -o sobrescribe sin preguntar: si ya tenías una copia del taller con tus respuestas, renómbrala antes.

Comprobación: generar_envios.py, taller_airflow.ipynb, taller_almacenamiento.ipynb, taller_calidad.ipynb, taller_iceberg.ipynb, taller_ingesta.ipynb, taller_kafka.ipynb, taller_mllib.ipynb, taller_optimizacion.ipynb, taller_pyspark.ipynb, taller_seguridad.ipynb, taller_spark_sql.ipynb, taller_spark.ipynb, taller_streaming.ipynb y taller_streaming_kafka.ipynb en la lista, junto con lo que ya tenías en notebooks (por ejemplo jupyter-paquetes.txt). En el navegador aparecen en el árbol de Jupyter sin reiniciar nada.

6. Apagar sin perder nada

Apagar también tiene niveles. La diferencia está en qué se conserva.

Tres cajas. dc stop: contenedores detenidos, HDFS, Python y notebooks intactos, vuelve con dc up -d. dc down: contenedores eliminados, volúmenes intactos, vuelve con dc up -d, que recrea los contenedores. dc down -v, resaltada: borra los volúmenes, HDFS vacío y sin Python 3.11, hay que rehacer los laboratorios.

Qué conserva cada forma de apagar.

Antes de apagar, guarda los notebooks (Ctrl+S) y cierra las SparkSession abiertas con spark.stop(). Después:

  1. Ctrl+C en la terminal de Jupyter, y confirma con y si lo pide.
  2. dc stop en la otra terminal.
dc stop
dc ps -a

Resultado: los ocho contenedores en estado Exited, cada uno con un código entre paréntesis. El código cuenta cómo terminó:

Código Qué significa ¿Hay que preocuparse?
Exited (143) El proceso recibió la señal de apagado (SIGTERM, 128 + 15) y terminó. No: es el apagado normal de los servicios de Hadoop.
Exited (137) El proceso no terminó a tiempo y Docker lo forzó (SIGKILL, 128 + 9). No para spark-client: su sleep infinity ignora la señal de apagado y Docker lo detiene a los 10 segundos.
Exited (255) El contenedor terminó de forma abrupta, por ejemplo porque se apagó WSL o el computador sin dc stop. Normalmente no: dc up -d lo recupera. Si HDFS reporta bloques faltantes después, revisa el paso 3.
Exited (0) El proceso terminó por su cuenta sin error. No en los servicios de este clúster, que no terminan solos: mira dc logs.

dc down elimina además los contenedores, pero conserva los volúmenes: el siguiente dc up -d los recrea con los mismos datos. dc down -v borra los volúmenes: HDFS queda vacío y se pierde el Python 3.11 de cpython311. No lo uses mientras sigas el libro.

7. Errores conocidos

Esta tabla reúne los síntomas que aparecieron al ejecutar los laboratorios y talleres del libro.

Síntoma Causa Arreglo
Cannot connect to the Docker daemon Docker no está encendido. Sección 3, paso 1.
docker compose ls no muestra hdfs-lab El proyecto está apagado y ls solo lista los que corren. docker compose ls -a.
Connection refused o Total Nodes:0 justo después de encender NameNode o NodeManagers todavía arrancando. Esperar unos segundos y repetir.
Safe mode is ON o Name node is in safe mode al escribir HDFS todavía no salió del modo seguro. hdfs dfsadmin -safemode wait.
Found orphan containers ([hdfs-lab-spark-client-1]) Se usó docker compose sin el segundo archivo y Compose no reconoce a spark-client. Es solo un aviso: usa dc. No uses --remove-orphans, que borraría el cliente.
Cannot run program "/opt/python/bin/python3": error=2 en las tareas Los NodeManagers se recrearon sin el volumen de Python. dc up -d y esperar dos nodos RUNNING.
Aplicación en ACCEPTED que no avanza YARN no tiene memoria libre para su ApplicationMaster: hay otra aplicación Spark abierta. Cierra la otra SparkSession o mata la aplicación con yarn application -kill <id>.
AssertionError al comprobar Python en el notebook Kernel equivocado. Elige Python del clúster en Jupyter.
127.0.0.1:8888 no abre El servidor de Jupyter no está corriendo o se cerró su terminal. Sección 3, paso 5.
localhost:4040 no abre No hay ninguna SparkSession abierta. Abre una sesión en el notebook; la página existe mientras dure.
Aviso de buildx al ejecutar dc build Falta el componente de construcción moderno de Docker. Inofensivo para el laboratorio. Si quieres quitarlo y Docker Engine viene del repositorio oficial de Docker, sudo apt install docker-buildx-plugin.
WARNING: log4j.properties is not found Hadoop no encuentra su archivo de configuración de registros en el cliente. Inofensivo; ignóralo.

Antes de sumar servicios nuevos al clúster, conviene saber cuánta memoria usa. Con los ocho contenedores encendidos, docker stats --no-stream muestra la memoria de cada uno; anótala para compararla después.

8. Ejercicios de operación de Spark sobre YARN

El taller de Spark con ejemplos mira el motor desde el código. Estos trece ejercicios lo miran desde la operación: envías aplicaciones con spark-submit, las sigues en el portal de YARN y en la Spark UI, ubicas al driver y a los executors, y provocas a propósito una aplicación en ACCEPTED y otra en KILLED. Se hacen en la terminal y en el navegador, sin Jupyter, y sirven para practicar lo que este apéndice explica.

Cada ejercicio da un objetivo, qué debes lograr y un análisis; tú construyes las órdenes. Las soluciones de referencia están al final de la sección: úsalas para comprobar tu trabajo después de intentarlo. Resolver un ejercicio es poder explicar por qué YARN y Spark respondieron como respondieron, no solo que la orden no dé error.

Tu herramienta de referencia: spark-submit --help, yarn application -help, yarn node -help. Saber leerla es parte del ejercicio.

Datos que ya dejó el laboratorio del cliente Spark:

Dato Valor
Atajo Compose (los dos YAML) dc() { docker compose -f compose.yaml -f compose.spark.yaml "$@"; }
JAR de ejemplos /opt/spark/examples/jars/spark-examples_2.12-3.5.3.jar
SparkPi clase org.apache.spark.examples.SparkPi
Wordcount Java clase org.apache.spark.examples.JavaWordCount
Texto de los laboratorios hdfs://namenode:9000/yarn/entrada/texto.txt
Portal YARN http://localhost:8088
UI del driver http://localhost:4040 mientras el driver vive

Requisitos previos:

  • Laboratorio del cliente Spark terminado (spark-client, dc, SparkPi de comprobación).
  • MapReduce y su taller de Streaming: sabes leer el tipo MAPREDUCE y un part-r-*.
  • Teoría de Spark: DAG, evaluación perezosa, driver, executors, aplicación / job / etapa / tarea.

Dónde se ejecuta cada orden:

  • HOST — Bash en ~/hdfs-docker-lab. Aquí defines dc (se pierde al cerrar la ventana).
  • CLIENTE — órdenes Spark y Hadoop dentro de spark-client (dc exec spark-client ...).
  • NAVEGADOR — ResourceManager :8088. La UI Spark :4040 solo existe con el driver arriba.

docker compose a secas no ve spark-client. Si dc ps no lista ese servicio, el atajo no está leyendo el segundo YAML.

Mapa de los ejercicios:

# Ejercicio Frente Concepto Dificultad
0 Clúster y cliente arriba Infra dc, no rehacer HDFS Básico
1 SparkPi y tipo SPARK Motor Mismo YARN, otro tipo Básico
2 Historia: MAPREDUCE frente a SPARK Motor Dos motores, un portal Básico
3 Wordcount Spark sobre el mismo texto Motor Shuffle en Spark Intermedio
4 Comparar con el wordcount MapReduce Motor Mismo conteo, otro job Intermedio
5 Aplicación, job, etapa, tarea Modelo Jerarquía de la teoría Intermedio
6 Dónde está el driver Arquitectura Modo client Intermedio
7 Dónde están los executors Arquitectura Contenedor YARN ≠ Docker Medio-alto
8 Un Pi más largo y :4040 Observación UI del driver Medio-alto
9 Job en ACCEPTED Recursos 2 GB por NodeManager Medio-alto
10 Matar una aplicación Spark Operación KILLED vs SUCCEEDED Medio-alto
11 SparkPi no lee HDFS Modelo MapReduce π vs SparkPi Intermedio
12 Reto integrador Mixto Explicar un DAG con evidencias Alto

Ejercicio 0. Clúster y cliente arriba

Objetivo: trabajar sobre el clúster ya montado, sin crear otro proyecto Compose.

Qué debes lograr:

  • Estar en ~/hdfs-docker-lab con el atajo dc activo.
  • Ocho servicios, incluido spark-client, en marcha (o arrancarlos sin recrear volúmenes).
  • Modo seguro OFF, tres DataNodes vivos, dos NodeManagers RUNNING.
  • /yarn/entrada/texto.txt todavía tiene las cuatro líneas de los laboratorios.

Análisis: ¿por qué docker compose ps a secas, sin el segundo archivo, no lista spark-client aunque el contenedor esté en marcha? Si el texto falta, ¿lo subes otra vez desde el cliente o desde el NameNode, y qué cambia?

Ejercicio 1. SparkPi y tipo SPARK

Objetivo: enviar SparkPi y reconocer el motor en el portal.

Qué debes lograr:

  • Lanzar SparkPi con spark-submit en modo client, master yarn, desde spark-client.
  • Ver en la terminal una estimación cercana a 3,14.
  • En :8088, una aplicación de nombre tipo Spark Pi, tipo SPARK, estado FINISHED / SUCCEEDED.

Análisis: en el laboratorio del cliente ya corriste SparkPi para comprobar que el contenedor hablaba con YARN. ¿Qué pregunta responde ahora, en este taller? ¿Por qué el tipo no es MAPREDUCE si YARN es el mismo?

Ejercicio 2. Historia: MAPREDUCE frente a SPARK

Objetivo: el portal mezcla motores. Tú los separas.

Qué debes lograr:

  • Listar aplicaciones en todos los estados (ALL).
  • Identificar al menos una MAPREDUCE (π o wordcount de MapReduce) y una SPARK (SparkPi).
  • Anotar Application ID, tipo y estado final de cada una.

Análisis: ¿qué pieza decide el tipo que ves: el ResourceManager, el ApplicationMaster o el JAR que enviaste? Si alguien dice “el job corrió en Hadoop”, ¿cómo contestas con esta tabla?

Ejercicio 3. Wordcount Spark sobre el mismo texto

Objetivo: un cálculo con shuffle (reagrupar por clave a través de la red), no solo π.

Qué debes lograr:

  • Enviar JavaWordCount sobre hdfs://namenode:9000/yarn/entrada/texto.txt.
  • Recuperar el conteo (este programa imprime en la salida estándar del driver; no tiene por qué dejar part-* en HDFS).
  • Confirmar en :8088 otra aplicación tipo SPARK.

Análisis: ¿por qué este ejemplo sí necesita el archivo de HDFS y SparkPi no? Relaciónalo con las tres fases de MapReduce: ¿dónde está aquí el equivalente de map, shuffle y reduce?

Ejercicio 4. Comparar con el wordcount MapReduce

Objetivo: el mismo diccionario, dos motores.

Qué debes lograr:

  • Releer un part-r-* de MapReduce que ya tengas (/yarn/salida_wc, /yarn/teoria_mr_wc o la salida de Streaming).
  • Poner lado a lado las seis claves: datos, hadoop, hdfs, mapreduce, spark, yarn.
  • Si una salida MapReduce no existe, no montes un clúster nuevo: relanza el JAR de ejemplos Hadoop desde el cliente que ya usas, a un directorio de salida nuevo.

Análisis: si los números coinciden, ¿qué quedó demostrado y qué no? (pista: coincidir no prueba que Spark “sea MapReduce por dentro”.)

Ejercicio 5. Aplicación, job, etapa, tarea

Objetivo: usar los cuatro términos de la teoría con una corrida real.

Qué debes lograr:

  • Para una aplicación Spark que hayas lanzado, decir: cuál es la aplicación YARN (application_…), cuándo nació el job (qué acción lo disparó), si hubo más de una etapa, y qué es una tarea.
  • Apoyarte en :8088 (detalle de la app) y, si alcanzas a abrirla, en :4040 (Jobs / Stages).

Análisis: SparkPi y el wordcount, ¿cuántos jobs YARN ves (uno o dos) y cuántas aplicaciones? ¿Por qué esa diferencia importa cuando alguien dice “lanzé dos jobs”?

Ejercicio 6. Dónde está el driver

Objetivo: modo client no es un adorno del YAML.

Qué debes lograr:

  • Explicar, con evidencia, que el driver (quien arma el plan y recoge el resultado) no corre como contenedor YARN de los NodeManagers.
  • Relacionarlo con spark.submit.deployMode / --deploy-mode client y con el hostname spark-client.

Análisis: si el driver estuviera en un contenedor YARN (cluster mode), ¿podrías usar Jupyter con el kernel en spark-client como en el laboratorio del cliente? ¿Por qué sí o por qué no?

Ejercicio 7. Dónde están los executors

Objetivo: contenedor YARN ≠ contenedor Docker.

Qué debes lograr:

  • Localizar en qué NodeManagers corrieron contenedores de tu aplicación Spark (intento, AM, executors).
  • Comprobar que no apareció un docker compose / dc ps nuevo: siguen los mismos ocho servicios.

Análisis: un executor pide heap + overhead (en el laboratorio: 512 MiB + 384 MiB). ¿Cuántos executors caben a la vez en un NodeManager de 2 GB si también hay que alojar el ApplicationMaster? Muestra la cuenta.

Ejercicio 8. Un Pi más largo y :4040

Objetivo: la UI Spark no es el portal de YARN.

Qué debes lograr:

  • Lanzar SparkPi con más slices (el entero al final del JAR) para que dure lo suficiente.
  • Mientras corre, abrir http://localhost:4040 y anotar al menos: nombre de la app, número de executors, una etapa o un job.
  • En :8088, el estado durante la corrida (RUNNING) y al terminar (FINISHED).

Análisis: al acabar el spark-submit, :4040 deja de responder. :8088 sigue. ¿Qué proceso servía la 4040 y por qué muere con el driver en modo client?

Ejercicio 9. Job en ACCEPTED

Objetivo: YARN aceptó la app y aún no le dio contenedores.

Qué debes lograr:

  • Dejar una aplicación Spark viva (un Pi largo, o no cerrar otra app) y lanzar otra Spark a la vez.
  • Capturar el síntoma ACCEPTED (portal o yarn application -list).
  • Liberar recursos y ver que la segunda pasa a RUNNING o que decides no lanzarla.

Análisis: ¿el cuello es HDFS, el cliente o la memoria de los NodeManagers? ¿Qué harías antes de subir spark.executor.memory?

Ejercicio 10. Matar una aplicación Spark

Objetivo: distinguir KILLED, FAILED y FINISHED / SUCCEEDED.

Qué debes lograr:

  • Lanzar un SparkPi largo.
  • Desde otra terminal, matar esa aplicación YARN por su application_….
  • Dejar evidencia del estado final y de que los contenedores volvieron al pool (yarn node -list / métricas de :8088).

Análisis: ¿matar la aplicación YARN mata el spark-submit del driver? ¿Qué verías en la terminal del cliente?

Ejercicio 11. SparkPi no lee HDFS

Objetivo: no todo trabajo Spark es “leer un txt y contar”.

Qué debes lograr:

  • Contrastar SparkPi (sin -input de texto) con el wordcount Spark y con el π de MapReduce (QuasiMonteCarlo).
  • Una frase por cada uno: ¿lee HDFS? ¿hay shuffle de palabras? ¿para qué sirve en este libro?

Análisis: “Spark siempre trabaja en memoria sobre archivos de HDFS”. Con estas tres corridas, ¿dónde se rompe esa frase?

Ejercicio 12. Reto integrador

Diseña una corrida (SparkPi o wordcount) y entrega un párrafo con evidencias, no un diario de comandos, que cubra:

  1. Qué aplicación YARN fue (ID, tipo SPARK, estado).
  2. Quién fue el driver y quiénes los executors (máquinas / servicios).
  3. Si hubo shuffle o no, y cómo lo sabes.
  4. Qué habría sido otro job MapReduce si hubieras encadenado dos pasos, y por qué Spark lo cuenta como un DAG de etapas.
  5. Qué no demostraste (por ejemplo: DataFrames, SQL, que “todo cabe en RAM”).

Diagnóstico

Síntoma Hacia dónde mirar
dc no lista spark-client Atajo sin el segundo YAML; ventana de terminal nueva
Connection refused a 9000 u 8088 Clúster HDFS/YARN no listo; no es un fallo de Spark
ACCEPTED eterno Otra Spark viva; 2 GB por NM; spark.stop / matar apps
:4040 no abre El spark-submit ya terminó (el driver se fue)
Wordcount “Path does not exist” Falta /yarn/entrada/texto.txt (laboratorio del cliente o de YARN)
Tipo MAPREDUCE cuando esperabas Spark Enviaste el JAR de Hadoop, no spark-submit

Listo cuando: tienes al menos una app SPARK de SparkPi y una de wordcount, sabes separarlas de las MAPREDUCE del portal, y puedes decir dónde corrió el driver y dónde los executors.

Soluciones de referencia

Consulta esta sección después de intentar cada ejercicio. Los comandos se ejecutan en HOST, dentro de ~/hdfs-docker-lab, con el atajo dc definido. Los identificadores application_… y las cifras exactas cambian en cada corrida.

Para no repetir las rutas largas, define también estas variables en la misma terminal:

dc() { docker compose -f compose.yaml -f compose.spark.yaml "$@"; }
SUBMIT="/opt/spark/bin/spark-submit --master yarn --deploy-mode client"
JAR=/opt/spark/examples/jars/spark-examples_2.12-3.5.3.jar

Ejercicio 0

cd ~/hdfs-docker-lab
dc ps
dc start        # solo si hay servicios detenidos; no recrea volúmenes
dc exec spark-client /opt/hadoop/bin/hdfs dfsadmin -safemode get
dc exec spark-client /opt/hadoop/bin/hdfs dfsadmin -report | grep "Live datanodes"
dc exec spark-client /opt/hadoop/bin/yarn node -list
dc exec spark-client /opt/hadoop/bin/hdfs dfs -cat /yarn/entrada/texto.txt

Análisis. docker compose a secas lee solo compose.yaml, que describe HDFS y YARN; spark-client está definido en compose.spark.yaml, así que no aparece. Si falta el texto, súbelo desde el cliente (paso 8 del laboratorio del cliente Spark): el resultado en HDFS es el mismo, solo cambia desde qué contenedor se ejecuta el comando.

Ejercicio 1

dc exec spark-client $SUBMIT --class org.apache.spark.examples.SparkPi $JAR 10

Busca Pi is roughly 3.14… entre los mensajes. En :8088, la aplicación se llama Spark Pi, tipo SPARK, FINISHED / SUCCEEDED.

Análisis. En el laboratorio, SparkPi respondía “¿el cliente habla con YARN?”. Aquí responde “¿qué motor usó YARN?”: el mismo ResourceManager registra la aplicación con otro tipo porque la envió otro cliente.

Ejercicio 2

dc exec spark-client /opt/hadoop/bin/yarn application -list -appStates ALL

Análisis. El tipo lo declara el cliente que envía la aplicación: spark-submit la registra como SPARK y el cliente de MapReduce (yarn jar con un JAR de MapReduce) como MAPREDUCE. El ResourceManager solo lo anota. “Corrió en Hadoop” no dice nada: la pregunta útil es qué motor la envió y en qué cola corrió.

Ejercicio 3

dc exec spark-client $SUBMIT --class org.apache.spark.examples.JavaWordCount $JAR \
  hdfs://namenode:9000/yarn/entrada/texto.txt

Salida esperada (el orden de las líneas puede variar, y van mezcladas con mensajes de log):

hadoop: 3
hdfs: 1
yarn: 3
mapreduce: 1
spark: 1
datos: 3

Análisis. SparkPi genera sus números al azar; el wordcount necesita un archivo que leer. En el programa, partir las líneas en palabras y formar pares (palabra, 1) es el map; reduceByKey provoca el shuffle y la suma es el reduce.

Ejercicio 4

dc exec spark-client /opt/hadoop/bin/hdfs dfs -ls /yarn
dc exec spark-client /opt/hadoop/bin/hdfs dfs -cat /yarn/salida_wc/part-r-00000

Si no existe ninguna salida de MapReduce, genera una nueva desde el mismo cliente:

dc exec spark-client /opt/hadoop/bin/yarn jar \
  /opt/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.1.jar \
  wordcount /yarn/entrada/texto.txt /yarn/taller_spark_mr_wc
dc exec spark-client /opt/hadoop/bin/hdfs dfs -cat /yarn/taller_spark_mr_wc/part-r-00000

Análisis. Que los conteos coincidan demuestra que ambos motores calcularon bien el mismo problema. No demuestra que Spark use MapReduce por dentro: son motores distintos que comparten HDFS, YARN y la idea de agrupar por clave.

Ejercicio 5

Análisis. Cada spark-submit es una aplicación YARN. SparkPi dispara un job (la acción reduce final) con una etapa, porque no hay shuffle: cada tarea suma sus dardos y el driver combina los resultados. El wordcount dispara un job (la acción collect) con dos etapas, separadas por el shuffle de reduceByKey. Una tarea es una etapa aplicada a una partición: SparkPi con 10 crea diez tareas en su única etapa. “Lancé dos jobs” suele querer decir “dos aplicaciones”: en la UI de Spark, cada una tiene su propia lista de jobs.

Ejercicio 6

Mientras corre una aplicación (por ejemplo, la del ejercicio 8), abre http://localhost:4040, pestaña Environment, y busca spark.submit.deployMode = client y spark.driver.host = spark-client. En :8088, el contenedor del ApplicationMaster de una aplicación en modo client no ejecuta tu programa: solo pide executors.

Análisis. En modo cluster el driver correría dentro de un contenedor YARN, en un NodeManager. El kernel de Jupyter necesita el driver en su propio proceso para devolver resultados a las celdas, así que no podrías trabajar interactivamente desde spark-client.

Ejercicio 7

Con una aplicación en marcha:

dc exec spark-client /opt/hadoop/bin/yarn applicationattempt -list <application_id>
dc exec spark-client /opt/hadoop/bin/yarn container -list <appattempt_id>
dc ps

Verás tres contenedores YARN —el ApplicationMaster y dos executors— repartidos entre nodemanager1 y nodemanager2, y los mismos ocho servicios de siempre en dc ps. Para una aplicación terminada, la misma información está en el detalle de la aplicación en :8088.

Análisis. Cada executor pide 512 MiB de heap + 384 MiB de overhead = 896 MiB. YARN redondea cada petición al múltiplo de yarn.scheduler.minimum-allocation-mb (256 MiB) inmediatamente superior: 1024 MiB. Un NodeManager ofrece 2048 MiB, así que caben dos contenedores por nodo: el que aloja al ApplicationMaster (512 + 384 MiB, también redondeado a 1024) solo tiene sitio para un executor más. En todo el clúster caben cuatro contenedores; una aplicación usa tres.

Ejercicio 8

dc exec spark-client $SUBMIT --class org.apache.spark.examples.SparkPi $JAR 2000

Mientras corre, abre http://localhost:4040: nombre Spark Pi, dos executors en Executors y una etapa con 2000 tareas en Stages. En :8088 la aplicación aparece RUNNING y, al terminar, FINISHED.

Análisis. La UI del puerto 4040 la sirve el driver. En modo client el driver es el proceso spark-submit dentro de spark-client: cuando termina, el puerto deja de responder. El portal de YARN lo sirve el ResourceManager, que sigue vivo.

Ejercicio 9

En una terminal, lanza un SparkPi largo (2000 o más). Mientras corre, en otra terminal (define otra vez dc, SUBMIT y JAR):

dc exec spark-client $SUBMIT --class org.apache.spark.examples.SparkPi $JAR 100
dc exec spark-client /opt/hadoop/bin/yarn application -list

La segunda aplicación queda en ACCEPTED. En su detalle en :8088, o con yarn application -status, el diagnóstico dice Queue's AM resource limit exceeded, con AM Resource Request = <memory:1024, vCores:1>. Cuando la primera termina, la segunda pasa a RUNNING.

Análisis. El cuello no es HDFS ni el cliente: es la capacidad de YARN. La cola default reserva solo una fracción del clúster para ApplicationMasters y la primera aplicación ya ocupa tres de los cuatro contenedores posibles. Antes de subir spark.executor.memory, revisa qué otras aplicaciones siguen vivas: subir la memoria hace que quepan menos contenedores.

Ejercicio 10

dc exec spark-client /opt/hadoop/bin/yarn application -list
dc exec spark-client /opt/hadoop/bin/yarn application -kill <application_id>
dc exec spark-client /opt/hadoop/bin/yarn application -status <application_id>

El estado final es KILLED. En :8088, las métricas del clúster vuelven a mostrar la memoria libre.

Análisis. Sí: al morir el ApplicationMaster, el driver pierde a sus executors y el spark-submit termina con un error que indica que la aplicación ya terminó o fue cancelada. KILLED significa que alguien la canceló; FAILED, que falló por sí misma; FINISHED / SUCCEEDED, que terminó bien.

Ejercicio 11

Corrida ¿Lee datos de HDFS? ¿Shuffle de palabras? Para qué sirve en este libro
SparkPi No; genera números al azar No Probar que spark-submit habla con YARN y observar el motor sin datos
Wordcount Spark Sí, el texto de cuatro líneas Sí, en reduceByKey Ver un DAG de dos etapas con shuffle
π de MapReduce (QuasiMonteCarlo) No lee un texto; usa HDFS para sus archivos de trabajo No hay palabras; un reduce combina los resultados Ver las fases map y reduce del motor clásico

Análisis. La frase falla dos veces: SparkPi no lee archivos de HDFS, y el wordcount, aunque cabe en memoria, necesita shuffle, que pasa por disco y red.

Ejercicio 12

Un ejemplo de párrafo con el wordcount:

La aplicación application_…_0012, de tipo SPARK, terminó FINISHED / SUCCEEDED. El driver corrió en spark-client en modo client (spark.submit.deployMode = client en la pestaña Environment), y los dos executors en nodemanager1 y nodemanager2, como contenedores YARN. Hubo shuffle: la UI muestra dos etapas, y la segunda leyó los datos que escribió la primera (Shuffle Read en Stages). En MapReduce, añadir un segundo paso —por ejemplo, ordenar las palabras por frecuencia— exigiría otro trabajo que leyera de HDFS la salida del primero; Spark lo añade como una etapa más del mismo DAG. No demostré nada sobre DataFrames ni SQL, ni que los datos quepan siempre en memoria.

Hoja de referencia

Para Comando
Definir el atajo dc() { docker compose -f compose.yaml -f compose.spark.yaml "$@"; }
Ver el proyecto, aunque esté apagado docker compose ls -a
Encender todo dc up -d
Estado de los contenedores dc ps -a
Esperar a HDFS dc exec spark-client /opt/hadoop/bin/hdfs dfsadmin -safemode wait
DataNodes vivos dc exec spark-client /opt/hadoop/bin/hdfs dfsadmin -report
Nodos de YARN dc exec spark-client /opt/hadoop/bin/yarn node -list
Aplicaciones de YARN dc exec spark-client /opt/hadoop/bin/yarn application -list -appStates ALL
Registros de una aplicación dc exec spark-client /opt/hadoop/bin/yarn logs -applicationId <id>
Listar HDFS dc exec spark-client /opt/hadoop/bin/hdfs dfs -ls /
Registro de un contenedor dc logs --tail 30 <servicio>
Abrir una terminal en el cliente dc exec spark-client bash
Memoria por contenedor docker stats --no-stream
Apagar sin borrar dc stop

Lista de verificación

  • dc está definido en cada terminal que usas.
  • dc ps -a muestra ocho contenedores en Up.
  • HDFS dice Safe mode is OFF y tiene tres DataNodes vivos.
  • YARN tiene dos NodeManagers en RUNNING.
  • Jupyter usa el kernel Python del clúster.
  • Al terminar: notebooks guardados, spark.stop(), Ctrl+C a Jupyter y dc stop.

Prácticas

  1. Apaga el clúster con dc stop, vuelve a encenderlo con los pasos de la sección 3 y comprueba con dc exec spark-client /opt/hadoop/bin/hdfs dfs -cat /yarn/entrada/texto.txt que el archivo del laboratorio del cliente Spark sigue ahí.
  2. Ejecuta dc ps -a después de apagar y explica el código de salida de namenode y el de spark-client.
  3. Abre una SparkSession en Jupyter, entra a localhost:4040 y ubica el nombre de la aplicación. Cierra la sesión con spark.stop() y vuelve a cargar la página. ¿Qué pasa?
  4. Explica con tus palabras por qué docker compose up -d deja el clúster encendido pero rompe el taller de MapReduce Streaming.
  1. El archivo debe mostrar sus cuatro líneas: dc stop no toca los volúmenes de HDFS. Si cat dice No such file or directory, revisa que estés en el proyecto hdfs-lab con docker compose ls -a.
  2. Lo esperado es Exited (143) en namenode, apagado normal por SIGTERM, y Exited (137) en spark-client, que Docker detiene a la fuerza después de 10 segundos porque sleep infinity ignora la señal.
  3. La página muestra la aplicación mientras la sesión está abierta. Después de spark.stop() el navegador no conecta: la Spark UI vive dentro del driver y se apaga con él. El ResourceManager, en localhost:8088, sí conserva la aplicación como FINISHED.
  4. docker compose up -d lee solo compose.yaml, donde los NodeManagers no montan cpython311. Compose ve una configuración distinta, recrea los dos NodeManagers sin el volumen y los deja funcionando. YARN los ve sanos, pero cuando Hadoop Streaming intenta lanzar /opt/python/bin/python3 en ellos, el archivo no existe.

Glosario

Término Significado en este apéndice
Proyecto de Compose Conjunto de contenedores, redes y volúmenes que Compose maneja con un nombre; aquí, hdfs-lab.
Overlay Segundo archivo de Compose que se aplica sobre el primero.
dc Atajo que llama a Compose con los dos archivos del clúster.
Volumen con nombre Disco administrado por Docker que sobrevive a los contenedores.
Puerto publicado Puerto del contenedor conectado con uno de tu equipo.
Modo seguro Estado de arranque en el que HDFS no acepta escrituras.
Código de salida Número con el que termina un proceso; 128 + n indica que lo terminó la señal n.
SIGTERM y SIGKILL Señales de apagado: la primera pide terminar; la segunda obliga.
Token de Jupyter Código de un solo arranque que autoriza al navegador a entrar en Jupyter.

Referencias para profundizar

Resumen

El clúster son ocho contenedores en el proyecto hdfs-lab, descritos por dos archivos de Compose; el atajo dc los usa siempre juntos y evita que los NodeManagers pierdan el Python del clúster. Encender es una secuencia: Docker, dc up -d, HDFS fuera del modo seguro con tres DataNodes, YARN con dos nodos y, en otra terminal, Jupyter. Los talleres llegan a Jupyter copiándolos en ~/hdfs-docker-lab/notebooks. Para apagar basta dc stop, que conserva todo; dc down -v borra los datos. Y cuando algo falla, la tabla de la sección 7 distingue lo que es arranque normal de lo que necesita arreglo. Los trece ejercicios de la sección 8 sirven para practicar todo eso con aplicaciones Spark reales.