Apache Spark con Scala: conjunto de datos distribuido resistente

En el mundo moderno, nos enfrentamos a grandes conjuntos de datos todos los días. Los datos están creciendo incluso más rápido que las velocidades de procesamiento. Para realizar cálculos en datos tan grandes, a menudo se logra mediante el uso de sistemas distribuidos. Un sistema distribuido consta de clústeres (Nodes/computadoras en red) que ejecutan procesos en paralelo y se comunican entre sí si es necesario.

Apache Spark es un motor de análisis unificado para el procesamiento de datos a gran escala. Proporciona API de alto nivel en Java, Scala, Python y R , y un motor optimizado que admite gráficos de ejecución general. Este amplio conjunto de funcionalidades y bibliotecas admitía herramientas de nivel superior como Spark SQL para SQL y procesamiento de datos estructurados, MLlib para aprendizaje automático, GraphX ​​para procesamiento de gráficos y transmisión estructurada para procesamiento de secuencias y computación incremental. En este artículo, aprenderemos Apache Spark (versión 2.x) usando Scala .

Algunos conceptos básicos: 

1. RDD (Conjunto de datos distribuido resistente) : es una colección distribuida inmutable de objetos. En el caso de RDD, el conjunto de datos es la parte principal y se divide en particiones lógicas.
2. SparkSession: el punto de entrada a la programación de Spark con la API Dataset y DataFrame.

Usaremos Scala IDE solo con fines de demostración. Se requiere un compilador Spark dedicado para ejecutar el siguiente código. Siga el enlace para ejecutar el siguiente código.

Creemos nuestro primer marco de datos en Spark.

// Importing SparkSession
import org.apache.spark.sql.SparkSession
 
// Creating SparkSession object
val sparkSession = SparkSession.builder()
                   .appName("My First Spark Application")
                   .master("local").getOrCreate()
 
// Loading sparkContext
val sparkContext = sparkSession.sparkContext
 
// Creating an RDD
val intArray = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
// parallelize method creates partitions, which additionally
// takes integer argument to specifies the number of partitions.
// Here we are using 3 partitions.
 
val intRDD = sparkContext.parallelize(intArray, 3)
 
// Printing number of partitions
println(s"Number of partitions in intRDD : ${intRDD.partitions.size}")
 
// Printing first element of RDD
println(s"First element in intRDD : ${intRDD.first}")
 
// Creating string from RDD
// take(n) function is used to fetch n elements from
// RDD and returns an Array.
// Then we will convert the Array to string using
// mkString function in scala.
val strFromRDD = intRDD.take(intRDD.count.toInt).mkString(", ")
println(s"String from intRDD : ${strFromRDD}")
 
// Printing contents of RDD
// collect function is used to retrieve all the data in an RDD.
println("Printing intRDD: ")
intRDD.collect().foreach(println)

Producción :  

Number of partitions in intRDD : 3
First element in intRDD : 1
String from intRDD : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Printing intRDD: 
1
2
3
4
5
6
7
8
9
10