Introducció a Apache Spark
Apache Spark és un motor de processament de dades de codi obert dissenyat per processar grans volums de dades de manera ràpida i eficient. A diferència de Hadoop MapReduce, Spark utilitza la computació en memòria per accelerar les operacions de processament de dades.
Característiques Clau de Spark
- Velocitat: Utilitza la memòria per a la majoria de les operacions, el que el fa molt més ràpid que Hadoop MapReduce.
- Facilitat d'ús: Proporciona APIs senzilles en Java, Scala, Python i R.
- Generalitat: Suporta una àmplia gamma de càrregues de treball, incloent-hi SQL, streaming, machine learning i processament de gràfics.
- Compatibilitat amb Hadoop: Pot llegir dades des de HDFS, HBase, Cassandra, entre altres.
Arquitectura de Spark
Spark segueix una arquitectura mestre-treballador (master-worker) composta per diversos components clau:
- Driver Program: El punt d'entrada de l'aplicació Spark. Controla l'execució de les tasques.
- Cluster Manager: Gestiona els recursos del clúster. Pot ser YARN, Mesos o el propi gestor de recursos de Spark.
- Executors: Processos que executen les tasques assignades pel Driver Program i emmagatzemen dades en memòria.
Diagrama de l'Arquitectura de Spark
+------------------+
| Driver Program |
+--------+---------+
|
v
+--------+---------+
| Cluster Manager |
+--------+---------+
|
v
+--------+---------+ +--------+---------+
| Executor | ... | Executor |
+------------------+ +------------------+RDDs (Resilient Distributed Datasets)
Els RDDs són la unitat fonamental de dades en Spark. Són col·leccions d'objectes distribuïdes a través d'un clúster que poden ser processades en paral·lel.
Operacions en RDDs
- Transformacions: Operacions que creen un nou RDD a partir d'un existent (e.g.,
map,filter). - Accions: Operacions que retornen un valor al driver després de processar l'RDD (e.g.,
collect,count).
Exemple de Transformació i Acció en RDD
from pyspark import SparkContext
sc = SparkContext("local", "Simple App")
data = [1, 2, 3, 4, 5]
rdd = sc.parallelize(data)
# Transformació: multiplicar cada element per 2
transformed_rdd = rdd.map(lambda x: x * 2)
# Acció: recollir els resultats
result = transformed_rdd.collect()
print(result) # Output: [2, 4, 6, 8, 10]Spark SQL
Spark SQL permet treballar amb dades estructurades utilitzant el llenguatge SQL. Proporciona el component DataFrame, que és una col·lecció distribuïda de dades organitzada en columnes.
Exemple d'Ús de DataFrame
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("Simple SQL App").getOrCreate()
data = [("Alice", 1), ("Bob", 2), ("Cathy", 3)]
columns = ["Name", "Value"]
df = spark.createDataFrame(data, columns)
df.show()
# Executar una consulta SQL
df.createOrReplaceTempView("people")
sqlDF = spark.sql("SELECT Name FROM people WHERE Value > 1")
sqlDF.show()Spark Streaming
Spark Streaming permet processar fluxos de dades en temps real. Utilitza DStreams (Discretized Streams), que són seqüències de RDDs.
Exemple de Spark Streaming
from pyspark import SparkContext
from pyspark.streaming import StreamingContext
sc = SparkContext("local[2]", "NetworkWordCount")
ssc = StreamingContext(sc, 1)
lines = ssc.socketTextStream("localhost", 9999)
words = lines.flatMap(lambda line: line.split(" "))
wordCounts = words.map(lambda word: (word, 1)).reduceByKey(lambda a, b: a + b)
wordCounts.pprint()
ssc.start()
ssc.awaitTermination()Exercicis Pràctics
Exercici 1: Creació i Transformació d'RDDs
- Crea un RDD amb els números del 1 al 10.
- Aplica una transformació per obtenir el quadrat de cada número.
- Recull i imprimeix els resultats.
Solució
from pyspark import SparkContext
sc = SparkContext("local", "Exercise 1")
data = list(range(1, 11))
rdd = sc.parallelize(data)
# Transformació: quadrat de cada número
squared_rdd = rdd.map(lambda x: x ** 2)
# Acció: recollir els resultats
result = squared_rdd.collect()
print(result) # Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]Exercici 2: Ús de DataFrames i Spark SQL
- Crea un DataFrame amb una llista de persones i les seves edats.
- Filtra les persones que tenen més de 30 anys utilitzant una consulta SQL.
- Mostra els resultats.
Solució
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("Exercise 2").getOrCreate()
data = [("Alice", 25), ("Bob", 35), ("Cathy", 45)]
columns = ["Name", "Age"]
df = spark.createDataFrame(data, columns)
df.createOrReplaceTempView("people")
# Consulta SQL per filtrar persones amb més de 30 anys
sqlDF = spark.sql("SELECT Name, Age FROM people WHERE Age > 30")
sqlDF.show()Resum
En aquesta secció, hem après sobre Apache Spark i la seva arquitectura, incloent-hi els components clau com el Driver Program, el Cluster Manager i els Executors. Hem explorat els RDDs, les seves transformacions i accions, així com l'ús de DataFrames i Spark SQL per treballar amb dades estructurades. També hem vist com processar fluxos de dades en temps real amb Spark Streaming. Finalment, hem reforçat els conceptes amb exercicis pràctics.
En el següent tema, explorarem el processament de fluxos de dades en més detall.
Curs d'Arquitectures Distribuïdes
Mòdul 1: Introducció als Sistemes Distribuïts
- Conceptes Bàsics de Sistemes Distribuïts
- Models de Sistemes Distribuïts
- Avantatges i Desafiaments dels Sistemes Distribuïts