El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Caché y Persistencia

Siguiente ►
►

En este módulo, aprenderemos sobre las técnicas de caché y persistencia en Apache Spark, que son fundamentales para optimizar el rendimiento de las aplicaciones. Estas técnicas permiten almacenar datos intermedios en memoria o en disco, reduciendo el tiempo de ejecución de las operaciones repetitivas.

Objetivos del Módulo

  • Entender la diferencia entre caché y persistencia.
  • Aprender a usar las funciones cache() y persist().
  • Conocer los diferentes niveles de almacenamiento disponibles en Spark.
  • Aplicar técnicas de caché y persistencia para optimizar aplicaciones Spark.

  1. ¿Qué es el Caché en Spark?

El caché en Spark es una técnica que permite almacenar un RDD (Resilient Distributed Dataset) en memoria para que pueda ser reutilizado en múltiples operaciones. Esto es útil cuando se realizan varias acciones sobre el mismo RDD, ya que evita la necesidad de recalcular el RDD desde cero cada vez.

Ejemplo de Uso de cache()

val rdd = sc.textFile("hdfs://path/to/file")
val words = rdd.flatMap(line => line.split(" "))
val wordCounts = words.map(word => (word, 1)).reduceByKey(_ + _)

// Cache the RDD
wordCounts.cache()

// Perform multiple actions
wordCounts.collect()
wordCounts.saveAsTextFile("hdfs://path/to/output")

En este ejemplo, el RDD wordCounts se almacena en memoria después de la primera acción (collect()). La segunda acción (saveAsTextFile()) reutiliza el RDD almacenado en memoria, lo que mejora el rendimiento.

  1. ¿Qué es la Persistencia en Spark?

La persistencia en Spark es una técnica más flexible que el caché. Permite almacenar un RDD en diferentes niveles de almacenamiento, como memoria, disco o una combinación de ambos. La función persist() se utiliza para especificar el nivel de almacenamiento deseado.

Niveles de Almacenamiento

Nivel de Almacenamiento Descripción
MEMORY_ONLY Almacena los datos en memoria. Si no hay suficiente memoria, se lanzará una excepción.
MEMORY_AND_DISK Almacena los datos en memoria y, si no hay suficiente memoria, en disco.
DISK_ONLY Almacena los datos solo en disco.
MEMORY_ONLY_SER Almacena los datos en memoria en formato serializado.
MEMORY_AND_DISK_SER Almacena los datos en memoria en formato serializado y, si no hay suficiente memoria, en disco.

Ejemplo de Uso de persist()

import org.apache.spark.storage.StorageLevel

val rdd = sc.textFile("hdfs://path/to/file")
val words = rdd.flatMap(line => line.split(" "))
val wordCounts = words.map(word => (word, 1)).reduceByKey(_ + _)

// Persist the RDD with MEMORY_AND_DISK level
wordCounts.persist(StorageLevel.MEMORY_AND_DISK)

// Perform multiple actions
wordCounts.collect()
wordCounts.saveAsTextFile("hdfs://path/to/output")

En este ejemplo, el RDD wordCounts se almacena en memoria y, si no hay suficiente memoria, en disco. Esto proporciona una mayor flexibilidad y robustez en comparación con el caché.

  1. Ejercicio Práctico

Ejercicio

  1. Crea un RDD a partir de un archivo de texto.
  2. Realiza una transformación para contar las palabras en el archivo.
  3. Utiliza cache() para almacenar el RDD en memoria.
  4. Realiza dos acciones diferentes sobre el RDD almacenado en memoria.
  5. Repite los pasos 1-4 utilizando persist() con el nivel de almacenamiento MEMORY_AND_DISK.

Solución

// Paso 1: Crear un RDD a partir de un archivo de texto
val rdd = sc.textFile("hdfs://path/to/file")

// Paso 2: Transformación para contar las palabras
val words = rdd.flatMap(line => line.split(" "))
val wordCounts = words.map(word => (word, 1)).reduceByKey(_ + _)

// Paso 3: Utilizar cache() para almacenar el RDD en memoria
wordCounts.cache()

// Paso 4: Realizar dos acciones diferentes
wordCounts.collect()
wordCounts.saveAsTextFile("hdfs://path/to/output")

// Repetir los pasos 1-4 utilizando persist() con MEMORY_AND_DISK
val rdd2 = sc.textFile("hdfs://path/to/file")
val words2 = rdd2.flatMap(line => line.split(" "))
val wordCounts2 = words2.map(word => (word, 1)).reduceByKey(_ + _)

// Utilizar persist() con MEMORY_AND_DISK
wordCounts2.persist(StorageLevel.MEMORY_AND_DISK)

// Realizar dos acciones diferentes
wordCounts2.collect()
wordCounts2.saveAsTextFile("hdfs://path/to/output2")

  1. Errores Comunes y Consejos

Errores Comunes

  • No usar cache() o persist() cuando se realizan múltiples acciones sobre el mismo RDD. Esto puede llevar a una recalculación innecesaria y a un rendimiento deficiente.
  • Elegir un nivel de almacenamiento inadecuado. Por ejemplo, usar MEMORY_ONLY cuando no hay suficiente memoria disponible puede causar errores.

Consejos

  • Monitorea el uso de memoria. Utiliza herramientas como el Spark UI para monitorear el uso de memoria y ajustar los niveles de almacenamiento según sea necesario.
  • Combina cache() y persist() con otras técnicas de optimización. Por ejemplo, usa particionamiento adecuado y evita operaciones costosas como groupByKey.

Conclusión

En este módulo, hemos aprendido sobre las técnicas de caché y persistencia en Apache Spark. Estas técnicas son esenciales para optimizar el rendimiento de las aplicaciones Spark, especialmente cuando se realizan múltiples acciones sobre el mismo RDD. Hemos visto cómo usar las funciones cache() y persist(), y hemos explorado los diferentes niveles de almacenamiento disponibles. Con esta base, estarás mejor preparado para escribir aplicaciones Spark más eficientes y robustas.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados