Resilient Distributed Datasets (RDDs) son la abstracción fundamental en Apache Spark. Un RDD es una colección distribuida de elementos que puede ser operada en paralelo. RDDs son inmutables, lo que significa que una vez creados, no pueden ser modificados. Sin embargo, puedes crear nuevos RDDs transformando los existentes.
Hay dos formas principales de crear RDDs:
Las operaciones sobre RDDs se dividen en dos categorías:
map, filter, flatMap).count, collect, first).
import org.apache.spark.{SparkConf, SparkContext}
object RDDExample {
def main(args: Array[String]): Unit = {
// Configuración de Spark
val conf = new SparkConf().setAppName("RDD Example").setMaster("local[*]")
val sc = new SparkContext(conf)
// Creación de un RDD a partir de una colección
val data = Array(1, 2, 3, 4, 5)
val rdd = sc.parallelize(data)
// Transformaciones
val rddSquared = rdd.map(x => x * x)
val rddFiltered = rddSquared.filter(x => x > 10)
// Acciones
val result = rddFiltered.collect()
// Imprimir el resultado
println("Elementos del RDD filtrado: " + result.mkString(", "))
// Finalizar SparkContext
sc.stop()
}
}
Configuración de Spark:
SparkConf para crear una configuración de Spark con un nombre de aplicación y establecer el modo de ejecución en local con todos los núcleos disponibles (local[*]).SparkContext con esta configuración, lo que permite interactuar con Spark.Creación de un RDD a partir de una colección:
sc.parallelize, creando un RDD.Transformaciones:
map: Se aplica una función a cada elemento del RDD original para crear un nuevo RDD donde cada elemento es el cuadrado del original.filter: Se filtran los elementos del RDD resultante para crear un nuevo RDD que solo contenga elementos mayores que 10.Acciones:
collect: Se recopilan los elementos del RDD filtrado en un array en el programa driver.Imprimir el Resultado:
Finalizar SparkContext:
SparkContext para liberar los recursos.DataFrames son una abstracción de datos en Apache Spark que permiten trabajar con datos estructurados de una manera similar a las tablas en una base de datos relacional o los data frames en R y Python. Los DataFrames proporcionan una API de alto nivel para manipular datos y son más eficientes que los RDDs debido a optimizaciones internas. Spark SQL es un módulo de Spark que permite trabajar con datos estructurados mediante consultas SQL.
Los DataFrames pueden ser creados a partir de diversas fuentes de datos, como archivos CSV, JSON, bases de datos, entre otros. Spark SQL permite realizar consultas SQL sobre DataFrames, lo que facilita la manipulación y análisis de datos.
import org.apache.spark.sql.{SparkSession, DataFrame}
object DataFrameExample {
def main(args: Array[String]): Unit = {
// Crear una SparkSession
val spark = SparkSession.builder
.appName("DataFrame Example")
.master("local[*]")
.getOrCreate()
// Leer un archivo CSV y crear un DataFrame
val df: DataFrame = spark.read.option("header", "true").csv("path/to/your/csvfile.csv")
// Mostrar el esquema del DataFrame
df.printSchema()
// Mostrar las primeras 5 filas del DataFrame
df.show(5)
// Crear una vista temporal para ejecutar consultas SQL
df.createOrReplaceTempView("my_table")
// Ejecutar una consulta SQL
val sqlDF: DataFrame = spark.sql("SELECT * FROM my_table WHERE some_column > 10")
// Mostrar el resultado de la consulta SQL
sqlDF.show()
// Finalizar SparkSession
spark.stop()
}
}
Crear una SparkSession:
SparkSession.builder para configurar y crear una nueva sesión de Spark con un nombre de aplicación y el modo de ejecución en local (local[*]).Leer un archivo CSV y crear un DataFrame:
spark.read.option("header", "true").csv("path/to/your/csvfile.csv") para leer un archivo CSV con encabezado y crear un DataFrame a partir de los datos del archivo.Mostrar el esquema del DataFrame:
df.printSchema() para imprimir el esquema del DataFrame, que muestra las columnas y sus tipos de datos.Mostrar las primeras 5 filas del DataFrame:
df.show(5) para mostrar las primeras 5 filas del DataFrame, lo que permite una vista rápida de los datos.Crear una vista temporal para ejecutar consultas SQL:
df.createOrReplaceTempView("my_table") para crear una vista temporal con el nombre «my_table», lo que permite ejecutar consultas SQL sobre este DataFrame.Ejecutar una consulta SQL:
spark.sql("SELECT * FROM my_table WHERE some_column > 10") para ejecutar una consulta SQL que selecciona todas las filas de «my_table» donde el valor de «some_column» es mayor que 10.Mostrar el resultado de la consulta SQL:
sqlDF.show() para mostrar los resultados de la consulta SQL.Finalizar SparkSession:
spark.stop() para detener la sesión de Spark y liberar los recursos.En Apache Spark, las operaciones sobre RDDs se dividen en dos categorías: transformaciones y acciones.
Transformaciones: Son operaciones que crean un nuevo RDD a partir de uno existente. Son perezosas (lazy), lo que significa que no se ejecutan inmediatamente sino hasta que se llama una acción. Ejemplos de transformaciones son map, filter, flatMap, reduceByKey, entre otras.
Acciones: Son operaciones que devuelven un valor o exportan datos desde un RDD. Las acciones son las que desencadenan la ejecución de las transformaciones pendientes. Ejemplos de acciones son collect, count, first, take, reduce, saveAsTextFile, entre otras.
import org.apache.spark.{SparkConf, SparkContext}
object TransformationsAndActions {
def main(args: Array[String]): Unit = {
// Configuración de Spark
val conf = new SparkConf().setAppName("Transformations and Actions Example").setMaster("local[*]")
val sc = new SparkContext(conf)
// Crear un RDD a partir de una colección
val data = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val rdd = sc.parallelize(data)
// Transformación: map (elevar al cuadrado cada elemento)
val squaredRdd = rdd.map(x => x * x)
// Transformación: filter (filtrar elementos mayores que 20)
val filteredRdd = squaredRdd.filter(x => x > 20)
// Acción: collect (recoger los elementos del RDD en un array)
val result = filteredRdd.collect()
// Acción: count (contar el número de elementos en el RDD)
val count = filteredRdd.count()
// Imprimir resultados
println("Elementos del RDD filtrado: " + result.mkString(", "))
println("Número de elementos en el RDD filtrado: " + count)
// Finalizar SparkContext
sc.stop()
}
}
Configuración de Spark:
SparkConf para crear una configuración de Spark con un nombre de aplicación y establecer el modo de ejecución en local (local[*]).SparkContext con esta configuración.Crear un RDD a partir de una colección:
sc.parallelize, creando un RDD.Transformación: map:
map al RDD original, creando un nuevo RDD (squaredRdd) donde cada elemento es el cuadrado del elemento original.Transformación: filter:
filter al RDD squaredRdd, creando un nuevo RDD (filteredRdd) que solo contiene elementos mayores que 20.Acción: collect:
collect al RDD filteredRdd, que recoge todos los elementos del RDD en un array y los devuelve al programa driver.Acción: count:
count al RDD filteredRdd, que cuenta el número de elementos en el RDD y devuelve el resultado.Imprimir Resultados:
collect y count, mostrando los elementos filtrados y el número de elementos en el RDD filtrado.Finalizar SparkContext:
SparkContext para liberar los recursos.