Apache Spark es una plataforma de procesamiento de datos en clústeres de código abierto diseñada para ser rápida y de propósito general. Spark proporciona una interfaz para la programación de clústeres completos con paralelismo implícito y tolerancia a fallos.

1. Velocidad: Spark puede ejecutar aplicaciones hasta 100 veces más rápido en memoria y 10 veces más rápido en disco que Hadoop MapReduce.
2. Facilidad de Uso: Spark tiene APIs fáciles de usar para Scala, Java, Python y R.
3. Generalidad: Spark combina SQL, streaming, y análisis complejos en una sola plataforma.
4. Compatibilidad con Hadoop: Spark puede ejecutarse en Hadoop, Mesos, Kubernetes, en la nube o de forma independiente.

1. Spark Core: El motor de procesamiento subyacente responsable de la programación, optimización y ejecución de tareas.
2. Spark SQL: Un módulo para trabajar con datos estructurados utilizando SQL.
3. Spark Streaming: Permite el procesamiento de flujos de datos en tiempo real.
4. MLlib (Machine Learning Library): Una biblioteca de aprendizaje automático escalable.
5. GraphX: Una API para gráficos y cálculos paralelos de gráficos.

• Java: Spark requiere Java 8 o superior.
• Scala: Aunque no es obligatorio, Scala es el lenguaje nativo de Spark.
• Python: Para usar PySpark, la API de Python para Spark.

1. Descargar Apache Spark:

   wget https://archive.apache.org/dist/spark/spark-3.1.2/spark-3.1.2-bin-hadoop2.7.tgz
   

2. Extraer el archivo descargado:

   tar -xvzf spark-3.1.2-bin-hadoop2.7.tgz
   

3. Configurar las variables de entorno:

   export SPARK_HOME=~/spark-3.1.2-bin-hadoop2.7
   export PATH=$PATH:$SPARK_HOME/bin
   

4. Verificar la instalación:

   spark-shell
   

Los RDD son la abstracción principal de Spark, representando una colección inmutable de objetos que se pueden dividir en particiones y procesar en paralelo.

Creación de un RDD

1. Desde una colección:

   from pyspark import SparkContext
   sc = SparkContext("local", "Simple App")
   data = [1, 2, 3, 4, 5]
   rdd = sc.parallelize(data)
   

2. Desde un archivo:

   rdd = sc.textFile("path/to/file.txt")
   

Operaciones en RDD

1. Transformaciones: Crean un nuevo RDD a partir de uno existente.

   • map(): Aplica una función a cada elemento del RDD.

     rdd2 = rdd.map(lambda x: x * 2)
     

   • filter(): Filtra los elementos del RDD según una función.

     rdd3 = rdd.filter(lambda x: x % 2 == 0)
     

2. Acciones: Devuelven un valor al controlador después de ejecutar una computación en el RDD.

   • collect(): Devuelve todos los elementos del RDD.

     result = rdd.collect()
     

   • count(): Devuelve el número de elementos en el RDD.

     count = rdd.count()
     

Los DataFrames son una abstracción de datos estructurados distribuidos, similar a una tabla en una base de datos relacional.

Creación de un DataFrame

1. Desde un RDD:

   from pyspark.sql import SparkSession
   spark = SparkSession.builder.appName("example").getOrCreate()
   df = spark.createDataFrame(rdd, schema=["value"])
   

2. Desde un archivo CSV:

   df = spark.read.csv("path/to/file.csv", header=True, inferSchema=True)
   

Operaciones en DataFrames

1. Selección de columnas:

   df.select("column_name").show()
   

2. Filtrado de filas:

   df.filter(df["column_name"] > 10).show()
   

3. Agrupación y agregación:

   df.groupBy("column_name").count().show()
   

Objetivo

Procesar un archivo de texto para contar la frecuencia de cada palabra.

Código

Explicación

1. Leer el archivo de texto: sc.textFile("path/to/textfile.txt") carga el archivo como un RDD.
2. Dividir las líneas en palabras: flatMap(lambda line: line.split(" ")) divide cada línea en palabras.
3. Mapear cada palabra a un par (palabra, 1): map(lambda word: (word, 1)) crea pares clave-valor.
4. Reducir por clave para contar las palabras: reduceByKey(add) suma los valores para cada clave.
5. Recoger y mostrar los resultados: counts.collect() devuelve los resultados al controlador.

En esta sección, hemos cubierto los conceptos básicos de Apache Spark, incluyendo sus componentes clave, la instalación, y la programación con RDDs y DataFrames. También hemos proporcionado un ejercicio práctico para contar la frecuencia de palabras en un archivo de texto. Con estos conocimientos, estás preparado para explorar más a fondo el procesamiento de Big Data con Apache Spark.