wsl --install

git clone --depth 1 --branch 26-27 https://github.com/dsevilla/tcdm-public.git ~/tcdm-public
cd ~/tcdm-public

%pip install -q "jupyter-notebook-slide @ git+https://github.com/dsevilla/jupyter-notebook-slide.git"
%load_ext notebook_slide

import notebook_slide as jnbs

# Colores para TCDM.
jnbs.configure(
    background="#eaf2f8",
    foreground="#1f2933",
    border="#c9d6e1",
    heading="#0c304d",
    subheading="#0c304d",
    link="#174f7a",
    code_background="#eaf2f8",
    code_foreground="#0c304d",
    quote_background="#ffffff",
    font_family="Atkinson Hyperlegible, Inter, Aptos, Segoe UI, Helvetica, Arial, sans-serif",
    font_url="https://fonts.googleapis.com/css2?family=Atkinson+Hyperlegible:ital,wght@0,400;0,700;1,400;1,700&display=swap",
)
jnbs.register_slide_type("avance", "A continuación", "#174f7a")
jnbs.register_slide_type("resumen", "Recapitulación", "#a54467")
jnbs.register_slide_type("pregunta", "Pregunta guía", "#0c304d")
jnbs.register_slide_type("evaluacion", "Evaluación de la sesión", "#b3701a")
jnbs.register_slide_type(
    "titulo",
    "Sección",
    "#174f7a",
    layout="title",
    background="linear-gradient(135deg, #0c304d, #174f7a 62%, #a54467)",
    foreground="#ffffff",
    border="transparent",
    heading="#ffffff",
    subheading="#dceaf4",
)
jnbs.register_alias("diapositiva")

!docker exec namenode su - luser -c 'hdfs dfs -ls /'
│ │           │        │            └─ orden que se ejecuta en el contenedor
│ │           │        └─ como el usuario luser, con su entorno de login
│ │           │           (PATH con hdfs, yarn, java...)
│ │           └─ dentro del contenedor namenode
│ └─ el cliente Docker de tu equipo entra en un contenedor
└─ Jupyter pasa el resto de la línea a una shell de tu equipo

!docker --version

!docker compose version

!docker info

/user/hdadmin
/user/luser
/tmp
/tmp/hadoop-yarn/staging
/tmp/logs
/datalake
/datalake/raw
/datalake/raw/tpcds
/datalake/silver
/datalake/gold
/warehouse

FROM ubuntu:26.04

ARG HADOOP_VERSION=3.5.0
ENV HADOOP_VERSION=${HADOOP_VERSION} \
    JAVA_HOME=/usr/lib/jvm/java-17-openjdk \
    HADOOP_HOME=/opt/bd/hadoop \
    HADOOP_CONF_DIR=/opt/bd/hadoop/etc/hadoop

!docker network inspect hadoop-cluster >/dev/null 2>&1 || docker network create hadoop-cluster

!docker compose -f ../entorno/compose-hadoop-cluster.yml up -d

!docker compose -f ../entorno/compose-hadoop-cluster.yml ps

docker exec -it namenode bash

!docker exec namenode su - hdadmin -c 'hdfs dfsadmin -report'

!docker exec namenode su - hdadmin -c 'yarn node -list -all -showDetails'

!docker exec namenode su - hdadmin -c 'jps'

!docker exec datanode1 su - hdadmin -c 'jps'

!docker exec datanode2 su - hdadmin -c 'jps'

!docker exec datanode3 su - hdadmin -c 'jps'

!docker exec namenode curl --fail --silent http://timelineserver:8188/ws/v1/timeline/

!docker exec namenode su - luser -c 'id'

!docker exec namenode su - luser -c 'command -v java && java -version'

!docker exec namenode su - luser -c 'command -v python3 && python3 --version'

!docker exec namenode su - luser -c 'command -v pip3'

!docker exec namenode su - luser -c 'command -v jupyter spark-submit'

!docker exec namenode su - luser -c 'command -v mvn'

!docker exec namenode su - luser -c 'command -v hadoop; command -v hdfs; command -v yarn; command -v mapred'

!docker exec namenode su - luser -c 'hadoop version'

!docker exec namenode su - luser -c 'printf "%s\n" "$HADOOP_HOME"'

!docker exec namenode su - luser -c 'hdfs dfs -ls /'

!docker exec namenode su - luser -c 'hdfs dfs -ls /user'

!docker exec namenode su - luser -c 'hdfs dfs -ls -d /datalake /datalake/raw /datalake/raw/tpcds /datalake/silver /datalake/gold'

!docker exec namenode su - luser -c 'hdfs dfs -ls -d /warehouse'

!docker exec namenode su - luser -c 'hdfs getconf -confKey dfs.replication'

!docker exec namenode su - luser -c 'hdfs getconf -confKey dfs.blocksize'

<?xml version="1.0"?>
<configuration>
  <property>
    <name>fs.defaultFS</name>
    <value>hdfs://namenode:9000/</value>
    <final>true</final>
  </property>
  <property>
    <name>hadoop.tmp.dir</name>
    <value>/var/tmp/hadoop-${user.name}</value>
    <final>true</final>
  </property>
</configuration>

<?xml version="1.0"?>
<configuration>
  <property>
    <name>dfs.replication</name>
    <value>3</value>
    <final>true</final>
  </property>
  <property>
    <name>dfs.blocksize</name>
    <value>64m</value>
    <final>true</final>
  </property>
  <property>
    <name>dfs.namenode.name.dir</name>
    <value>file:///var/data/hdfs/namenode</value>
    <final>true</final>
  </property>
  <property>
    <name>dfs.image.compress</name>
    <value>true</value>
  </property>
  <property>
    <name>dfs.webhdfs.enabled</name>
    <value>true</value>
  </property>
  <property>
    <name>hadoop.http.authentication.type</name>
    <value>simple</value>
  </property>
  <property>
    <name>hadoop.http.filter.initializers</name>
    <value></value>
  </property>
  <property>
    <name>dfs.namenode.http-address</name>
    <value>namenode:9870</value>
  </property>
</configuration>

<?xml version="1.0"?>
<configuration>
  <property>
    <name>dfs.replication</name>
    <value>3</value>
    <final>true</final>
  </property>
  <property>
    <name>dfs.blocksize</name>
    <value>64m</value>
    <final>true</final>
  </property>
  <property>
    <name>dfs.datanode.data.dir</name>
    <value>file:///var/data/hdfs/datanode</value>
    <final>true</final>
  </property>
  <property>
    <name>dfs.webhdfs.enabled</name>
    <value>true</value>
  </property>
</configuration>

<?xml version="1.0"?>
<configuration>
  <property>
    <name>yarn.resourcemanager.hostname</name>
    <value>resourcemanager</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.timeline-service.enabled</name>
    <value>true</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.timeline-service.hostname</name>
    <value>timelineserver</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.timeline-service.address</name>
    <value>timelineserver:10200</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.timeline-service.webapp.address</name>
    <value>timelineserver:8188</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.timeline-service.bind-host</name>
    <value>0.0.0.0</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.system-metrics-publisher.enabled</name>
    <value>true</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.timeline-service.generic-application-history.enabled</name>
    <value>true</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.timeline-service.store-class</name>
    <value>org.apache.hadoop.yarn.server.timeline.LeveldbTimelineStore</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.timeline-service.leveldb-timeline-store.path</name>
    <value>/var/data/yarn/timeline</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.timeline-service.http-authentication.type</name>
    <value>simple</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.timeline-service.http-authentication.simple.anonymous.allowed</name>
    <value>true</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.log-aggregation-enable</name>
    <value>true</value>
  </property>
  <property>
    <name>yarn.nodemanager.remote-app-log-dir</name>
    <value>/tmp/logs</value>
  </property>
  <property>
    <name>yarn.nodemanager.log-aggregation.compression-type</name>
    <value>gz</value>
  </property>
  <property>
    <name>yarn.scheduler.maximum-allocation-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>2560</value>
  </property>
</configuration>

<property>
  <name>yarn.nodemanager.resource.detect-hardware-capabilities</name>
  <value>false</value>
</property>
<property>
  <name>yarn.nodemanager.resource.cpu-vcores</name>
  <value>2</value>
</property>
<property>
  <name>yarn.nodemanager.resource.memory-mb</name>
  <value>2560</value>
</property>
<property>
  <name>yarn.nodemanager.vmem-check-enabled</name>
  <value>false</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>

<?xml version="1.0"?>
<configuration>
  <property>
    <name>mapreduce.framework.name</name>
    <value>yarn</value>
    <final>true</final>
  </property>
  <property>
    <name>yarn.app.mapreduce.am.env</name>
    <value>HADOOP_MAPRED_HOME=${HADOOP_HOME}</value>
  </property>
  <property>
    <name>yarn.app.mapreduce.am.resource.cpu-vcores</name>
    <value>1</value>
  </property>
  <property>
    <name>yarn.app.mapreduce.am.resource.mb</name>
    <value>512</value>
  </property>
  <property>
    <name>mapreduce.job.heap.memory-mb.ratio</name>
    <value>0.8</value>
  </property>
  <property>
    <name>mapreduce.map.env</name>
    <value>HADOOP_MAPRED_HOME=${HADOOP_HOME}</value>
  </property>
  <property>
    <name>mapreduce.map.cpu.vcores</name>
    <value>1</value>
  </property>
  <property>
    <name>mapreduce.map.java.opts</name>
    <value>-Xmx512M</value>
  </property>
  <property>
    <name>mapreduce.map.memory.mb</name>
    <value>768</value>
  </property>
  <property>
    <name>mapreduce.reduce.env</name>
    <value>HADOOP_MAPRED_HOME=${HADOOP_HOME}</value>
  </property>
  <property>
    <name>mapreduce.reduce.cpu.vcores</name>
    <value>1</value>
  </property>
  <property>
    <name>mapreduce.reduce.java.opts</name>
    <value>-Xmx512M</value>
  </property>
  <property>
    <name>mapreduce.reduce.memory.mb</name>
    <value>768</value>
  </property>
</configuration>

!docker exec namenode su - luser -c 'hdfs getconf -confKey fs.defaultFS'

!docker exec namenode su - luser -c 'hdfs dfs -mkdir -p /user/luser/s1/input'

!docker exec namenode su - luser -c 'hdfs dfs -ls -R /user/luser/s1'

!docker exec namenode su - luser -c 'printf "hadoop hdfs mapreduce\nhadoop yarn\n" > /tmp/s1-a.txt'

!docker exec namenode su - luser -c 'printf "hdfs hadoop\nyarn recursos\n" > /tmp/s1-b.txt'

!docker exec namenode su - luser -c 'printf "mapreduce datos hadoop\ndatos datos\n" > /tmp/s1-c.txt'

!docker exec namenode su - luser -c 'cat /tmp/s1-a.txt'

!docker exec namenode su - luser -c 'hdfs dfs -put -f /tmp/s1-a.txt /user/luser/s1/input/'

!docker exec namenode su - luser -c 'hdfs dfs -put -f /tmp/s1-b.txt /user/luser/s1/input/'

!docker exec namenode su - luser -c 'hdfs dfs -put -f /tmp/s1-c.txt /user/luser/s1/input/'

!docker exec namenode su - luser -c 'hdfs dfs -ls -h /user/luser/s1/input'

!docker exec namenode su - luser -c 'hdfs dfs -cat /user/luser/s1/input/s1-a.txt'

!docker exec namenode su - luser -c 'hdfs dfs -cp /user/luser/s1/input/s1-a.txt /user/luser/s1/s1-a-copia.txt'

!docker exec namenode su - luser -c 'hdfs dfs -mv /user/luser/s1/s1-a-copia.txt /user/luser/s1/s1-a-renombrado.txt'

!docker exec namenode su - luser -c 'hdfs dfs -ls /user/luser/s1'

!docker exec namenode su - luser -c 'hdfs dfs -get -f /user/luser/s1/s1-a-renombrado.txt /tmp/s1-descargado.txt'

!docker exec namenode su - luser -c 'cat /tmp/s1-descargado.txt'

!docker exec namenode su - luser -c 'hdfs dfs -du -h /user/luser/s1/input'

!docker exec namenode su - hdadmin -c 'hdfs fsck /user/luser/s1/input -files -blocks -locations'

from mrjob.job import MRJob


class MRWordCount(MRJob):
    def mapper(self, _, line: str):
        # map(K1, V1) -> list(K2, V2)
        # K1 no se usa; V1 es la línea de texto.
        # Cada palabra de la línea produce un par intermedio (palabra, 1).
        for word in line.split():
            yield word.lower(), 1

    def combiner(self, word: str, counts: list[int]):
        # Suma parcial en el mismo nodo que ejecutó el mapper, antes de
        # enviar nada por la red. Válido porque sumar es conmutativo y
        # asociativo (ver más arriba).
        yield word, sum(counts)

    def reducer(self, word: str, counts: list[int]):
        # reduce(K2, list(V2)) -> (K3, list(V3))
        # `counts` es list(V2): los valores que MrJob ya agrupó por clave
        # durante el shuffle. Aquí la lista de salida tiene un único valor.
        yield word, sum(counts)


if __name__ == "__main__":
    MRWordCount.run()

$ printf 'hadoop hdfs mapreduce\nhadoop yarn\nhdfs hadoop\nyarn recursos\nmapreduce datos hadoop\ndatos datos\n' \
    | python3 wordcount_mrjob.py

!docker exec namenode su - luser -c 'hdfs dfs -rm -r -f /user/luser/s1/output'

!docker exec namenode su - luser -c 'yarn jar "$HADOOP_HOME"/share/hadoop/mapreduce/hadoop-mapreduce-examples-*.jar wordcount /user/luser/s1/input /user/luser/s1/output'

!docker exec namenode su - luser -c 'hdfs dfs -ls /user/luser/s1/output'

datos      3
hadoop     4
hdfs       2
mapreduce  2
recursos   1
yarn       2

!docker exec namenode su - luser -c 'hdfs dfs -cat /user/luser/s1/output/part-r-*'

!docker exec namenode su - hdadmin -c 'mapred job -list all'

!docker exec namenode su - hdadmin -c 'yarn application -list -appStates ALL'

docker compose -f entorno/compose-hadoop-cluster.yml ps -a
docker compose -f entorno/compose-hadoop-cluster.yml logs --tail=120
docker logs namenode --tail=120
docker logs datanode1 --tail=120

cd ~/tcdm-public
git pull

Nivel	Ejemplo	Dónde se ejecuta
Shell de tu equipo	`!docker compose -f ../entorno/compose-hadoop-cluster.yml ps`	En tu equipo; sólo necesita el cliente Docker
Contenedor	`!docker exec namenode ...`	Dentro de `namenode` (o del `datanodeN` que se indique)
Usuario del contenedor	`su - hdadmin -c '...'` o `su - luser -c '...'`	`hdadmin` administra los demonios; `luser` trabaja con los datos

Contenedor	Servicios	Responsabilidad principal
`namenode`	NameNode, ResourceManager y Timeline Server	Metadatos de HDFS, coordinación de recursos de cómputo e histórico de aplicaciones YARN
`datanode1`	DataNode y NodeManager	Almacena bloques y ejecuta tareas
`datanode2`	DataNode y NodeManager	Almacena bloques y ejecuta tareas
`datanode3`	DataNode y NodeManager	Almacena bloques y ejecuta tareas

Contenedor	Límite Docker	Recursos anunciados a YARN
`namenode`	2 vCPU y 4096 MiB	No ejecuta NodeManager
`datanode1`	2 vCPU y 3072 MiB	2 vcores y 2560 MiB
`datanode2`	2 vCPU y 3072 MiB	2 vcores y 2560 MiB
`datanode3`	2 vCPU y 3072 MiB	2 vcores y 2560 MiB

Imagen	Contenedores que la utilizan
`dsevilla/namenode-image:26-27`	`namenode`
`dsevilla/datanode-image:26-27`	Los tres `datanodeN`

Imagen	Contenido añadido	Imagen de partida
`dsevilla/hadoop-base:26-27`	Ubuntu, Java, Hadoop, utilidades y usuarios	`ubuntu:26.04`
`dsevilla/namenode-image:26-27`	Configuración de NameNode y ResourceManager, HDFS inicial	`hadoop-base:26-27`
`dsevilla/datanode-image:26-27`	Configuración de DataNode y NodeManager	`hadoop-base:26-27`

Proceso	Qué mantiene o ejecuta
`NameNode`	Espacio de nombres, permisos y localización de los bloques HDFS
`DataNode`	Bloques de datos guardados en el almacenamiento local del nodo
`ResourceManager`	Vista global de recursos y planificación de aplicaciones
`ApplicationHistoryServer`	Histórico y consulta de información de aplicaciones YARN (Timeline Server)
`NodeManager`	Contenedores YARN y recursos disponibles en un nodo

Situación	Orden	Consecuencia
Parar temporalmente	`docker compose -f entorno/compose-hadoop-cluster.yml stop`	Conserva contenedores y datos HDFS; se reanuda con `start`. Tras `start` los demonios tardan unos segundos en registrarse: repite `dfsadmin -report` y `yarn node -list -all` antes de continuar.
Reanudar	`docker compose -f entorno/compose-hadoop-cluster.yml start`	Vuelve a poner en marcha los mismos contenedores. `up -d` también sirve: Compose reutiliza los contenedores existentes mientras su configuración no obligue a recrearlos.
Limpiar sólo tus datos de la sesión	`docker exec namenode su - luser -c 'hdfs dfs -rm -r -f /user/luser/s1'`	Borra el área `/user/luser/s1` para repetir la sesión desde cero sin regenerar el clúster. No borra `/warehouse`, `/tmp`, `/user` ni los directorios de otros usuarios, ni detiene contenedores ni borra `/tmp` local.
Eliminar los contenedores	`docker compose -f entorno/compose-hadoop-cluster.yml down`	Elimina los contenedores, pero conserva los datos HDFS: viven en los volúmenes Docker `tcdm-26-27-namenode-data` y `tcdm-26-27-datanodeN-data` (en el Compose aparecen con los nombres cortos `namenode-data`/`datanodeN-data`), no en la capa de escritura de los contenedores. Sí borra el almacén local (no persistido) del Timeline Server. La red externa `hadoop-cluster` no se elimina.
Recrear los contenedores	`down` seguido de `up -d`	Los mismos volúmenes HDFS se vuelven a montar: `/user/luser`, `/datalake`, `/warehouse`, los datos de `/user/luser/s1` y un TPC-DS ya materializado siguen ahí. No hace falta reconstruir las imágenes.
Borrar también el HDFS (destructivo)	`docker volume rm tcdm-26-27-namenode-data tcdm-26-27-datanode1-data tcdm-26-27-datanode2-data tcdm-26-27-datanode3-data` (con los contenedores ya eliminados)	Vacía el espacio de nombres y los bloques: el próximo `up -d` arranca con un HDFS recién formateado, como la primera vez. Es la única orden de esta tabla que borra `/datalake/raw/tpcds` y cualquier otro dato ya materializado en sesiones posteriores.

Orden	Qué hace	Cuándo se usa
`make -C entorno hadoop-up`	Crea la red `hadoop-cluster` si falta y arranca `namenode` y los tres DataNodes. Si estaban parados, los reanuda; si ya funcionan, no hace nada	Al empezar cualquier sesión. Equivale a las órdenes `docker network create` y `docker compose ... up -d` de esta sesión
`make -C entorno warehouse-up`	Lo anterior y, además, PostgreSQL, Hive Metastore y Trino	Desde la sesión 2; sus ficheros llegan con el `git pull` de esa sesión
`make -C entorno jupyter`	Arranca Jupyter Lab dentro de `namenode` como `luser`; la terminal queda ocupada mientras Jupyter esté en marcha	Desde la sesión 2. Es el atajo de `docker exec -it namenode bash`, `su - luser` y `jupyter lab ...`
`make -C entorno status`	Lista los contenedores del laboratorio, tanto los que están en marcha como los parados	En cualquier momento, para saber en qué estado está el laboratorio

Orden	Qué hace	Qué se conserva	Qué se pierde
`make -C entorno stop`	Para los contenedores sin eliminarlos (`docker compose stop`)	Todo: los datos HDFS y también el interior de cada contenedor (ficheros locales, histórico del Timeline Server)	Sólo los procesos en marcha, entre ellos Jupyter
`make -C entorno down`	Elimina los contenedores (`docker compose down`)	Los volúmenes Docker, con todos los datos HDFS	Lo que vivía dentro de los contenedores: ficheros locales e histórico del Timeline Server
`make -C entorno clean`	`down` y, además, borra los volúmenes de los servicios que añaden la sesión 2 (Hive Metastore) y la sesión 3 (almacenamiento de objetos)	Todo HDFS	Las definiciones de tablas y los objetos de esos servicios. Con sólo el clúster de esta sesión equivale a `down`
`make -C entorno clean-hdfs`	`clean` y, además, borra los volúmenes HDFS: es el `docker volume rm` de «Detener, limpiar y recuperar el entorno»	Sólo las imágenes ya descargadas	Todos los datos: el siguiente arranque parte de un HDFS recién formateado

Sesión 1 — Entorno Hadoop con contenedores¶

Requisitos previos en Windows: WSL2 y Docker Desktop¶

Obtener el material de las sesiones¶

Diapositivas de la sesión¶

Sesión 1: HDFS, YARN y MapReduce

Cómo se evalúa esta sesión

Las tres piezas de Hadoop

Hadoop, HDFS, YARN y MapReduce¶

HDFS como sistema de ficheros distribuido¶

YARN como gestor de recursos¶

MapReduce como modelo de procesamiento¶

Referencias¶

De dónde sale Hadoop

Por qué existe Big Data y por qué apareció MapReduce¶

El mapa de tecnologías Big Data

Retos tecnológicos de Big Data¶

Búsqueda y refinamiento¶

Serialización¶

Sistemas de almacenamiento¶

Servidores¶

Procesamiento¶

Bases de datos¶

Análisis y BI¶

Procesamiento de lenguaje natural¶

Machine Learning y Deep Learning¶

Visualización¶

Panorama de tecnologías Big Data¶

Por qué Hadoop asume que todo falla

Procesamiento del Big Data: por qué Hadoop existe¶

Problemas en la ejecución y cómo los resuelve Hadoop¶

Desafío 1: Los nodos baratos fallan constantemente¶

Desafío 2: Las redes baratas tienen elevada latencia¶

Desafío 3: Programar un sistema distribuido es difícil¶

Las piezas antes de tocarlas

Objetivos de la sesión¶

Preparamos el entorno y conocemos el clúster

Antes de empezar¶

Dónde se ejecuta cada orden¶

Comprobar el cliente Docker¶

Comprobar Docker Compose¶

Comprobar el motor de contenedores¶

El clúster que vamos a usar

El clúster que se va a utilizar¶

Recursos asignados¶

Imágenes del curso¶

Identidades y seguridad del laboratorio¶

Directorios HDFS iniciales¶

Cómo se construyen las imágenes (referencia)

Cómo se construyen las imágenes del curso¶

Tres imágenes relacionadas¶

Receta de la imagen base¶

Dockerfiles de las imágenes de servicio¶

Entorno Python del curso (sólo en el NameNode)¶

Usuarios y entorno de ejecución¶

Formateo e inicialización incluidos en la imagen¶

Arranque automático de los demonios¶

Preparar la red del laboratorio¶

El entorno está listo para ser lanzado

Arrancamos el clúster

Arrancar el clúster¶

Ver el estado de los contenedores¶

Observar el clúster desde el navegador¶

Ejecutar las órdenes desde una terminal del contenedor¶

Comprobar HDFS y YARN¶

Relacionar servicios y procesos con jps¶

Consultar el Timeline Server desde la red interna¶

El clúster está vivo

Exploramos el clúster como luser

Explorar las herramientas instaladas¶

Explorar HDFS como luser¶

Replicación y tamaño de bloque¶

La configuración real de Hadoop

Comprobar la configuración efectiva de Hadoop¶

yarn-site.xml, recursos y servicios de YARN

La configuración explica lo ya observado

Ficheros de verdad en HDFS

Crear el área de trabajo de la sesión¶

Operaciones básicas con ficheros en HDFS¶

Subir los ficheros a HDFS¶

Listar y leer los datos distribuidos¶

Relacionar servicios y procesos con `jps`¶

Exploramos el clúster como `luser`

Explorar HDFS como `luser`¶

`yarn-site.xml`, recursos y servicios de YARN