Un RDD, según Spark, se define como una colección de elementos que es tolerante a fallos y que es capaz de operar en paralelo.

Es importante recalcar el tema de que sea capaz de operar en paralelo, porque es la clave o la filosofía básica de Apache Spark.

¿Cuáles son sus características principales?

Los RDDs tienen como características principales las siguientes:

  • Es la principal abstracción de datos, el tipo de dato básico que tiene Apache Spark.
  • Los RDD están particionados en los distintos nodos del clúster, ya que Apache Spark se suele instalar en un clúster o conjunto de máquinas, por lo que esos RRDs se encuentran distribuidos sobre esas máquinas. Con ello se consigue la tolerancia a fallos, porque si falla una máquina tenemos el fichero en otras máquinas.
  • Se suelen crear a partir de un fichero del HDFS, el sistema de ficheros distribuidos de Hadoop.
  • Usan la evaluación perezosa, que consiste en que todas las transformaciones que vayamos haciendo a los RDDs se van a ir almacenando en un DAG y no se van a resolver hasta que no quede más remedio, hasta que la herramienta esté obligada a realizarlas. Esta evaluación perezosa tiene una ventaja y un inconveniente, la primera es que ganamos tiempo, y el inconveniente es que si falla, no lo vamos a ver hasta que se resuelva el grafo completo.

SparkConf y SparkContext

Son el tipo de objeto básico a la hora de comenzar a crear los RDDs.

  • SparkContext nos va a cómo vamos a acceder a nuestro clúster.
  • SparkConf va a tener información acerca de nuestra aplicación, ya sea el número de hilos, la memoria que queramos que consuma, etc.

Práctica con RDD

Vamos a realizar una pequeña práctica con los RDD, en la cual vamos a crear un RDD y vamos a realizar alguna modificación.

Tenemos abierto un Jupyter, un notebook con Scala y con Spark, y tenemos ya creado un SparkContext. Si lo ejecutamos con sc comprobamos que está creado.

Vamos a crear un RDD, para ello creamos una variable llamada cadenas, y también vamos a crear un array con distintas palabras:

val cadenas = Array(“Openwebinars”, “bigdata”, “Openwebinars”)

Para convertir este array en un RDD nos vamos a apoyar en el objeto de SparkContext:

val cadenasRDD = sc . parallelize (cadenas)

Si lo ejecutamos, tendremos generado un cadenasRDD de tipo String.

Para poder ver su contenido podemos hacerlo de esta forma:

cadenasRDD.collect()

Como ya hemos comentado, no siempre se crean los RDD de esta manera. Lo que se hace normalmente es crearlo a partir de un fichero:

val file = sc.textFile(“/home/vmuser/textoRDD”, 6)

Esto crea un RDD de tipo String con el contenido del fichero indicado y con las particiones que indiquemos, en este caso 6.

Podemos ver el contenido de ese RDD:

file.collect()

Esto ya, al ser un RDD, se encontrará distribuido y podremos hacer cualquier tipo de operaciones con el mismo.

Para aplicar un filtro a nuestro RDD, de forma que nos muestre el filtro de las líneas que contengan la palabra Openwebinars:

val filtro = cadenasRDD.filter(line => line.contains(“Openwebinars”))

Para finalizar os mostramos cómo funciona la evaluación perezosa. Vamos a intentar cargar un fichero que no existe y le indicamos que nos lo divida en 6 partes:

val fileNotFound = sc.textFile(“/7añljdlsjd/alkls/”, 6)

Al lanzar lo anterior, se almacena en el grafo dirigido esa instrucción sin mostrar ningún tipo de error, ya que el error no lo va a mostrar hasta que no ejecutemos una acción sobre ese RDD:

fileNotFound.collect()