El procesamiento de grandes volúmenes de datos Big Data Processing
Es el conjunto de técnicas y tecnologías
Para recopilar, almacenar, transformar y analizar.
Datos masivos de manera eficiente.
Procesamiento de Grandes Volúmenes de Datos
Implica trabajar con datasets.
No pueden ser procesados por sistemas tradicionales
Debido a su tamaño, velocidad o complejidad.
Características del Big Data
Volumen: Datos en terabytes o petabytes.
Velocidad: Generación y procesamiento en tiempo real.
Variedad: Datos estructurados, semi-estructurados y no estructurados.
Ejemplo:
Google procesa 20 petabytes de datos al día.
Tecnologías para el Procesamiento de Big Data
| Tecnología | Uso Principal |
| Apache Spark | Procesamiento distribuido en memoria |
| Hadoop | Almacenamiento y análisis masivo con MapReduce |
| Kafka | Procesamiento en tiempo real de flujos de datos |
| Airflow | Orquestación de flujos de datos |
Transformación de Datos
Es el proceso de convertir datos crudos
En un formato más útil y estructurado.
Ejemplos de Transformaciones
Conversión de formatos: JSON → CSV → Parquet.
Agrupación de datos: Resumir millones de registros en métricas clave.
Filtrado y limpieza: Eliminar datos irrelevantes o incorrectos.
Limpieza de Datos
Elimina inconsistencias, valores faltantes.
Errores en los datos.
Tipos de Problemas en los Datos
Valores nulos o duplicados.
Errores tipográficos o de formato.
Datos inconsistentes
Fechas incorrectas, valores negativos en precios.
Procesamiento de grandes volúmenes de datos = Carga y análisis eficiente de datos masivos.
Transformación de datos = Conversión de datos crudos en información útil.
Limpieza de datos = Eliminación de errores e inconsistencias.
Hadoop → Almacenamiento y Procesamiento en Big Data
Hadoop es un sistema de almacenamiento y procesamiento.
Distribuido basado en el paradigma MapReduce.
Hadoop es un ecosistema de Big Data
Permite almacenar y procesar grandes volúmenes de datos.
De manera distribuida.
Componentes principales:
HDFS Hadoop Distributed File System: Sistema de almacenamiento distribuido.
MapReduce: Modelo de procesamiento de datos en paralelo.
YARN: Administrador de recursos y tareas en Hadoop.
Casos de uso:
Procesamiento de petabytes de datos.
Análisis de logs y datos no estructurados.
Data Lakes en empresas.
Ejemplo: Contar palabras en un archivo con Hadoop MapReduce
from mrjob.job import MRJob
class WordCount(MRJob):
def mapper(self, _, line):
for word in line.split():
yield word.lower(), 1
def reducer(self, word, counts):
yield word, sum(counts)
if __name__ == «__main__»:
WordCount.run()
Explicación:
Este código cuenta palabras en un archivo.
Distribuido en varios servidores usando MapReduce.
Hadoop almacena los datos en HDFS Hadoop Distributed File System.
Caso de uso: Análisis de Logs de Servidores Web
Imagina que una empresa de e-commerce quiere analizar los logs.
De sus servidores web millones de registros diarios
Para detectar tendencias y errores.
1. Almacenar Logs en HDFS
Comando para subir logs de 10GB a HDFS
hdfs dfs -mkdir /logs
hdfs dfs -put access.log /logs/
Explicación:
Crea un directorio en HDFS y almacena el archivo de logs en él.
2. Procesar Logs con MapReduce
Ejemplo en Python: Contar visitas por IP usando Hadoop Streaming
Paso 1: Crear script de mapeo (mapper.py)
import sys
for line in sys.stdin:
fields = line.strip().split(» «)
if len(fields) > 0:
print(f»{fields[0]}\t1″)
Explicación:
Extrae la dirección IP de cada línea del log y emite clave (IP) → valor (1).
Paso 2: Crear script de reducción (reducer.py)
import sys
from collections import defaultdict
counts = defaultdict(int)
for line in sys.stdin:
ip, count = line.strip().split(«\t»)
counts[ip] += int(count)
for ip, total in counts.items():
print(f»{ip}\t{total}»)
Explicación:
Suma todas las visitas por IP.
Paso 3: Ejecutar en Hadoop
hadoop jar /usr/lib/hadoop-mapreduce/hadoop-streaming.jar \
-input /logs/access.log \
-output /logs/output \
-mapper «python3 mapper.py» \
-reducer «python3 reducer.py»
Resultado:
Genera una lista con el total de visitas por cada IP.
Salida esperada:
192.168.1.1 1200
192.168.1.2 890
Este análisis permite detectar IPs sospechosas o tráfico anómalo.
Apache Kafka → Procesamiento en Tiempo Real
Kafka es una plataforma de mensajería distribuida utilizada para procesar datos en streaming tiempo real.
Casos de uso:
Procesar logs en vivo de servidores.
Monitorizar transacciones bancarias en tiempo real.
Enviar datos a Machine Learning en streaming.
Componentes principales:
Producer: Publica mensajes en Kafka.
Broker: Nodo que almacena los mensajes.
Topic: Categoría de mensajes.
Consumer: Lee los mensajes en tiempo real.
Ejemplo: Kafka productor y consumidor en Python
Productor (envía mensajes a un tema en Kafka)
from kafka import KafkaProducer
import json
producer = KafkaProducer(bootstrap_servers=»localhost:9092″, value_serializer=lambda v: json.dumps(v).encode(«utf-8»))
mensaje = {«usuario»: «juan», «compra»: 200}
producer.send(«compras», mensaje)
print(«Mensaje enviado»)
Explicación:
Kafka recibe eventos en tiempo real de usuarios.
Comprando en un e-commerce.
Consumidor (lee los mensajes en streaming)
from kafka import KafkaConsumer
import json
consumer = KafkaConsumer(«compras», bootstrap_servers=»localhost:9092″, value_deserializer=lambda m: json.loads(m.decode(«utf-8»)))
for mensaje in consumer:
print(f»Compra recibida: {mensaje.value}»)
Explicación:
Kafka procesa los eventos en tiempo real y permite reaccionar inmediatamente.
Caso de uso: Monitoreo en Tiempo Real de Transacciones Bancarias
Un banco quiere detectar transacciones fraudulentas en tiempo real.
1. Configurar un Kafka Topic para recibir transacciones
Crear un topic llamado transacciones
kafka-topics.sh –create –topic transacciones –bootstrap-server localhost:9092 –partitions 3 –replication-factor 2
Explicación:
Kafka dividirá el procesamiento en 3 particiones para mejorar el rendimiento.
2. Productor: Enviar transacciones en tiempo real
from kafka import KafkaProducer
import json
import time
import random
producer = KafkaProducer(bootstrap_servers=»localhost:9092″,
value_serializer=lambda v: json.dumps(v).encode(«utf-8»))
usuarios = [«Carlos», «Ana», «Pedro», «Sofia»] bancos = [«BBVA», «Santander», «CaixaBank»]
while True:
transaccion = {
«usuario»: random.choice(usuarios),
«monto»: random.randint(10, 5000),
«banco»: random.choice(bancos)
}
producer.send(«transacciones», transaccion)
print(f» Enviando: {transaccion}»)
time.sleep(1)
Explicación:
Cada segundo, genera una transacción aleatoria y la envía a Kafka.
Consumidor: Detectar Fraudes en Tiempo Real
from kafka import KafkaConsumer
import json
consumer = KafkaConsumer(«transacciones»,
bootstrap_servers=»localhost:9092″,
value_deserializer=lambda m: json.loads(m.decode(«utf-8»)))
for mensaje in consumer:
transaccion = mensaje.value
if transaccion[«monto»] > 3000:
print(f»ALERTA DE FRAUDE: {transaccion}»)
else:
print(f»Transacción OK: {transaccion}»)
Explicación:
Si la transacción es mayor a 3000€, genera una alerta de fraude.
Resultado esperado
Transacción OK: {‘usuario’: ‘Ana’, ‘monto’: 850, ‘banco’: ‘Santander’}
Transacción OK: {‘usuario’: ‘Pedro’, ‘monto’: 2700, ‘banco’: ‘BBVA’}
ALERTA DE FRAUDE: {‘usuario’: ‘Sofia’, ‘monto’: 4500, ‘banco’: ‘CaixaBank’}
El banco puede bloquear automáticamente la transacción sospechosa.
| Tecnología | Uso Principal | Caso de Uso |
| Hadoop | Almacenamiento y procesamiento distribuido | Análisis de logs de servidores |
| Kafka | Procesamiento en tiempo real | Monitoreo de fraudes bancarios |
