As 20 principais perguntas da entrevista com o Spark

O Apache Spark é um mecanismo de análise unificado para engenharia de dados, ciência de dados e machine learning em escala. Ele pode ser usado com Python, SQL, R, Java ou Scala. O Spark foi originalmente criado na Universidade da Califórnia, em Berkeley, em 2009, e depois foi doado à Apache Software Foundation em 2013. Atualmente, ele é "o mecanismo mais amplamente usado para computação dimensionável", com milhares de publicações de trabalhos que utilizam a tecnologia. Por ser uma habilidade tão valorizada no mundo da engenharia de dados, aqui estão algumas perguntas de entrevista para ajudar você a procurar emprego ou talentos que tenham experiência com o Spark. As respostas de codificação serão fornecidas em Python.

Perguntas básicas da entrevista com o Spark

Essas perguntas abrangem alguns dos fundamentos do Spark e são apropriadas para aqueles que têm apenas experiência básica em seu uso. Se você precisar de uma atualização, nossa Introdução ao Spark SQL em Python é o lugar ideal para você começar.

1. O que é o Apache Spark e por que ele é usado no processamento de dados?

Essa pergunta avalia a compreensão geral do candidato sobre o Apache Spark e seu papel no ecossistema de big data.

Resposta:

O Apache Spark é um sistema de computação distribuída de código aberto que fornece uma interface para programar clusters inteiros com paralelismo de dados implícito e tolerância a falhas. Ele é usado para processamento de dados em grande escala devido à sua velocidade e facilidade de uso em comparação com o MapReduce tradicional.

Principais recursos:

• Computação na memória: Armazena dados na memória para um processamento mais rápido.
• Escalabilidade: Pode lidar com petabytes de dados usando um cluster de máquinas.
• Facilidade de uso: Fornece APIs em Java, Scala, Python e R.
• Unified Analytics Engine: Oferece suporte a SQL, dados de streaming, machine learning e processamento de gráficos.

2. Explicar o conceito de RDDs (Resilient Distributed Datasets, conjuntos de dados distribuídos resilientes)

Esta pergunta testa você sobre os conceitos fundamentais do Apache Spark. Certifique-se de que você entenda um dos componentes críticos que tornam o Spark tão poderoso.

Os conjuntos de dados distribuídos resilientes (RDDs) são os blocos de construção fundamentais do Apache Spark. Eles representam uma coleção imutável e distribuída de objetos que podem ser operados em paralelo em um cluster. Aqui você encontra uma explicação das principais características e conceitos associados aos RDDs:

1. Imutável: Os RDDs são imutáveis, ou seja, uma vez criados, seu conteúdo não pode ser modificado. Você só pode transformar RDDs aplicando transformações para criar novos RDDs. Essa imutabilidade simplifica a tolerância a falhas e permite que você use o modelo de avaliação preguiçosa do Spark.
2. Distribuído: Os RDDs são distribuídos em vários nós em um cluster, permitindo que o Spark realize operações paralelas neles. Cada RDD é dividido em várias partições, e essas partições podem ser processadas independentemente em nós diferentes.
3. Resiliente: O termo "Resiliente" em RDD significa tolerância a falhas. O Spark garante a resiliência ao manter o controle da linhagem de cada RDD. Se uma partição de um RDD for perdida devido a uma falha de nó, o Spark poderá recomputar essa partição usando as informações de linhagem e as transformações aplicadas aos dados originais.
4. Conjunto de dados: Os RDDs são uma representação distribuída de dados, o que significa que eles podem conter qualquer tipo de dados, inclusive dados estruturados ou não estruturados. O Spark fornece APIs em várias linguagens (como Scala, Java, Python e R) para que você trabalhe com RDDs, tornando-o versátil para vários casos de uso e tipos de dados.
5. Avaliação preguiçosa: Os RDDs suportam avaliação preguiçosa, o que significa que as transformações nos RDDs não são executadas imediatamente. Em vez disso, o Spark constrói um gráfico acíclico direcionado (DAG) de transformações que definem a computação, mas atrasa a execução até que uma ação seja acionada. Essa otimização permite que o Spark otimize o plano de execução e melhore o desempenho.

3. O que é YARN?

O YARN é um gerenciador de contêineres distribuídos que gerencia recursos no Hadoop. O Spark pode utilizar o YARN ao ser executado em clusters do Hadoop para um gerenciamento de recursos mais eficaz e eficiente. Um dos componentes essenciais do YARN é sua capacidade de alocar recursos de forma eficiente no cluster, agendar trabalhos de forma eficiente e ser tolerante a falhas no caso de falhas de nós. É um dos muitos componentes que tornam o Spark uma ferramenta poderosa.

4. Qual é a diferença entre as transformações map e flatMap nos RDDs do Spark?

Essa pergunta ajuda a determinar se você entende os diferentes tipos de transformações nos RDDs (Resilient Distributed Datasets) do Spark.

Resposta:

• .map(): Transforma cada elemento do RDD em exatamente um novo elemento. O resultado é um RDD com o mesmo número de elementos que o RDD de entrada.
• .flatMap(): Transforma cada elemento do RDD em zero ou mais elementos novos. O resultado é um RDD com números de elementos potencialmente diferentes do RDD de entrada.

# Example of map
rdd = spark.sparkContext.parallelize([1, 2, 3])
mapped_rdd = rdd.map(lambda x: x * 2)
print(mapped_rdd.collect())  # Output: [2, 4, 6]
# Example of flatMap
flat_mapped_rdd = rdd.flatMap(lambda x: [x, x * 2])
print(flat_mapped_rdd.collect())  # Output: [1, 2, 2, 4, 3, 6]

Este código ilustra a diferença entre map e flatMap, transformando um RDD de números inteiros.

5. Como você usa o Spark SQL para consultar dados de um DataFrame?

Essa pergunta verifica a capacidade do candidato de usar o Spark SQL para consultar dados, o que é essencial para tarefas de análise de dados.

Resposta:

# Register the DataFrame as a SQL temporary view
df.createOrReplaceTempView("table")
# Execute SQL query
result = spark.sql("SELECT column1, SUM(column2) FROM table GROUP BY column1")
# Show the results
result.show()

Este snippet demonstra como você pode criar uma exibição temporária a partir de um DataFrame e usar o Spark SQL para realizar uma consulta group-by.

Perguntas intermediárias da entrevista com o Spark

Para aqueles que dominam os conceitos básicos e os aplicam em suas funções profissionais, essas perguntas podem ser mais comuns: 

6. Explicar o conceito de avaliação preguiçosa no Spark e por que ele é importante.

Essa pergunta avalia a compreensão do candidato sobre um dos princípios fundamentais do Spark, que é crucial para otimizar o desempenho.

Resposta:

A avaliação preguiçosa significa que o Spark não executa imediatamente as transformações quando elas são chamadas. Em vez disso, ele cria um plano de execução lógico. As transformações são executadas somente quando uma ação (como coletar ou contar) é chamada, o que aciona o cálculo real.

A avaliação preguiçosa é importante por dois motivos:

1. Isso permite que o Spark otimize todo o fluxo de trabalho de processamento de dados antes de executá-lo, combinando operações para minimizar o embaralhamento de dados.
2. Ele reduz o número de passagens pelos dados, melhorando o desempenho.

7. Como você mantém os dados no Spark e quais são os diferentes níveis de armazenamento disponíveis?

Essa pergunta verifica o conhecimento do candidato sobre persistência de dados no Spark, o que é importante para o ajuste de desempenho e os algoritmos iterativos.

Resposta:

Os dados podem ser mantidos no Spark usando os métodos .persist() ou .cache(). .cache() é uma abreviação de .persist() com o nível de armazenamento padrão.

Níveis de armazenamento:

• MEMORY_ONLY: Armazena RDD como objetos Java desserializados na JVM. Se o RDD não couber na memória, algumas partições não serão armazenadas em cache.
• MEMORY_AND_DISK: Armazena RDD como objetos Java desserializados na memória. Se o RDD não couber na memória, as partições serão armazenadas no disco.
• MEMORY_ONLY_SER: Armazena RDD como objetos Java serializados na JVM. Isso reduz o uso da memória, mas aumenta a sobrecarga da CPU para serialização/desserialização.
• MEMORY_AND_DISK_SER: Semelhante ao MEMORY_AND_DISK, mas armazena objetos serializados.
• DISK_ONLY: Armazena as partições RDD somente no disco.

rdd = spark.sparkContext.parallelize([1, 2, 3, 4, 5])
rdd.persist(storageLevel=StorageLevel.MEMORY_AND_DISK)

8. Como você lida com dados distorcidos no Spark?

Essa pergunta avalia a compreensão do candidato sobre a distorção de dados e como gerenciá-la, o que é fundamental para garantir um processamento de dados eficiente.

Resposta:

A distorção de dados ocorre quando algumas partições têm significativamente mais dados do que outras, o que leva a gargalos de desempenho. As estratégias para lidar com dados distorcidos incluem:

• Salga: Adicionar uma chave aleatória aos dados para distribuí-los de forma mais uniforme entre as partições.
• Reparticionamento: Aumentar o número de partições para distribuir os dados de forma mais uniforme.
• Variáveis de transmissão: Transmissão de um pequeno conjunto de dados a todos os nós para evitar o embaralhamento de grandes conjuntos de dados.

from pyspark.sql.functions import monotonically_increasing_id, col
# Example of salting
df = df.withColumn("salt", monotonically_increasing_id() % 10)
df = df.withColumn("new_key", col("original_key") + col("salt"))

9. Explique a diferença entre transformações estreitas e amplas no Spark

Esta pergunta testa a compreensão que o candidato tem do modelo de execução do Spark e o impacto de diferentes tipos de transformações no desempenho.

Resposta:

• Transformações estreitas: Operações em que cada partição de entrada contribui para exatamente uma partição de saída. Os exemplos incluem .map(), .filter() e .union(). Em geral, eles são mais rápidos porque não exigem o embaralhamento de dados.
• Transformações amplas: Operações em que cada partição de entrada contribui para várias partições de saída. Os exemplos incluem .groupByKey(), .reduceByKey() e .join(). Eles exigem o embaralhamento de dados na rede, o que pode consumir muito tempo.

# Narrow transformation example
rdd1 = rdd.map(lambda x: x * 2)
# Wide transformation example
rdd2 = rdd.groupByKey()

10. Spark Streaming no processamento de dados em tempo real

O Spark é excelente em streaming de dados em tempo real de fontes como Apache Kafka ou Amazon Kinesis porque é escalável e tolerante a falhas. Isso é feito por meio da extensão Spark Streaming. Ele interage com fontes de dados externas usando DStreams de entrada, que representam um fluxo contínuo de dados dessas fontes. 

O Spark Streaming garante a tolerância a falhas e a consistência dos dados por meio de técnicas como checkpointing e registros de gravação antecipada. O checkpointing salva periodicamente o estado do aplicativo de streaming no armazenamento durável (por exemplo, HDFS) para se recuperar de falhas, enquanto os registros de gravação antecipada oferecem tolerância a falhas para dados recebidos de fontes externas.

Perguntas avançadas da entrevista sobre o Spark

Essas perguntas são para usuários com mais experiência prática com o Spark, especialmente com tópicos mais sofisticados. Se você precisar de uma atualização, confira nosso artigo Spark Machine Learning do Spark.

11. Discuta como o Spark pode ser utilizado para machine learning

Esta pergunta testa a compreensão que o entrevistado tem do ambiente do Spark e da biblioteca MLib. 

A biblioteca MLlib do Spark fornece um rico conjunto de ferramentas e algoritmos para que você realize tarefas de machine learning em escala. Quando se trata de engenharia de recursos e pré-processamento para conjuntos de dados em grande escala, o MLlib oferece várias técnicas e otimizações avançadas:

1. Transformação e seleção de recursos: O MLlib oferece uma série de técnicas de transformação de recursos, como dimensionamento, normalização, binarização e vetorização (por exemplo, codificação de um ponto). Além disso, ele oferece métodos para seleção de recursos, incluindo filtragem baseada em correlação, ganho de informações ou testes estatísticos, bem como técnicas mais avançadas, como análise de componentes principais (PCA) para redução da dimensionalidade.

2. Manipulação de recursos categóricos: O MLlib inclui ferramentas para o tratamento eficiente de recursos categóricos, como o StringIndexer, para converter variáveis categóricas em representações numéricas, e o OneHotEncoder, para convertê-las em vetores binários. Essas transformações são otimizadas para execução paralela em clusters distribuídos do Spark.

3. API de pipeline: A API de pipeline do Spark permite que os usuários encadeiem vários estágios de engenharia e modelagem de recursos em um único fluxo de trabalho. Isso facilita a criação de pipelines de transformação de recursos complexos e, ao mesmo tempo, garante a consistência e a reprodutibilidade em diferentes conjuntos de dados e tarefas de machine learning.

4. Transformadores e estimadores personalizados: O MLlib permite que os usuários definam transformadores e estimadores de recursos personalizados usando a API DataFrame do Spark. Isso permite que você integre técnicas de engenharia de recursos específicas do domínio ou bibliotecas de terceiros no pipeline de ML do Spark, ampliando sua funcionalidade e flexibilidade.

12. Explicar como o Spark se integra a sistemas de armazenamento externo, como o Apache Hadoop HDFS e o Apache Cassandra. Quais são as vantagens de você aproveitar essas integrações em um pipeline de dados baseado no Spark?

Isso testa se os usuários entendem a funcionalidade subjacente dos sistemas baseados no Spark e como o Spark funciona com o HDFS e o Apache Cassandra. É importante que você entenda como recuperar dados por meio da codificação e como esses dados se movem pelo sistema.

1. Conexão HDFS do Hadoop: O Spark se integra a sistemas de armazenamento externo, como o Apache Hadoop HDFS e o Apache Cassandra, por meio de conectores ou bibliotecas projetados especificamente para cada sistema. Por exemplo, a integração do HDFS é nativa do Spark, permitindo que o Spark leia e grave dados diretamente de/para o HDFS usando as APIs InputFormat e OutputFormat do Hadoop.
2. Conexão do Apache Cassandra: As vantagens de aproveitar essas integrações incluem melhor desempenho devido à localidade dos dados (no caso do HDFS), acesso e manipulação simplificados de dados e compatibilidade com a infraestrutura de dados existente. Além disso, o Spark pode explorar a natureza distribuída desses sistemas de armazenamento para processamento paralelo, permitindo que você processe dados em escala.

13. Explique a você o conceito de variáveis de transmissão no Spark.

As variáveis de difusão no Spark são variáveis somente leitura que são armazenadas em cache e disponibilizadas para todos os nós de trabalho em um aplicativo Spark distribuído. Eles são usados para distribuir com eficiência conjuntos de dados ou valores grandes e somente leitura para nós de trabalho, reduzindo assim a sobrecarga da rede e melhorando o desempenho da tarefa. 

As variáveis de transmissão são serializadas e enviadas para cada nó de trabalho apenas uma vez, onde são armazenadas em cache na memória e reutilizadas em várias tarefas. Isso elimina a necessidade de enviar a variável com cada tarefa, reduzindo a sobrecarga de transferência de dados, especialmente para grandes conjuntos de dados.

• Utilização: As variáveis de difusão são comumente usadas em cenários em que um grande conjunto de dados ou valor precisa ser compartilhado entre várias tarefas ou estágios de computação. Por exemplo, em operações de união em que um DataFrame ou RDD é significativamente menor que o outro, a transmissão do DataFrame/RDD menor pode reduzir significativamente a quantidade de dados embaralhados na rede durante a operação de união.
• Cenários benéficos:
• Junte-se às operações: A transmissão de conjuntos de dados menores para operações de união pode melhorar muito o desempenho, reduzindo o tráfego de rede e acelerando a execução de tarefas.
• Tabelas de pesquisa: Ao transmitir pequenas tabelas de pesquisa ou dicionários usados para operações de enriquecimento ou filtragem, você pode melhorar o desempenho, evitando transferências repetidas de dados.
• Machine Learning: A transmissão de vetores de recursos ou parâmetros de modelos para nós de trabalho durante o treinamento distribuído pode acelerar o processo de treinamento, especialmente quando os vetores de recursos ou parâmetros são relativamente pequenos em comparação com o conjunto de dados.
• Desafios:
• Sobrecarga de memória: A transmissão de variáveis grandes pode consumir uma quantidade significativa de memória nos nós de trabalho, o que pode levar a erros de falta de memória se não for gerenciada com cuidado.
• Congestionamento de rede: A transmissão de variáveis grandes também pode causar congestionamento na rede durante a fase inicial de transmissão, especialmente em clusters grandes com largura de banda de rede limitada.
• Dados dinâmicos: As variáveis de transmissão são imutáveis depois de transmitidas, portanto, não são adequadas para cenários em que os dados transmitidos precisam ser atualizados dinamicamente durante a execução do trabalho do Spark.

14. Como você otimiza um trabalho do Spark usando particionamento e coalescência? 

Essa pergunta avalia a capacidade do candidato de otimizar os trabalhos do Spark, uma habilidade fundamental para melhorar o desempenho e a eficiência. Com o ajuste de desempenho do Spark, podemos aproveitar a estrutura distribuída do Spark usando particionamento e coalescência, que gerencia a distribuição da carga de trabalho no cluster para que você realize operações de dados mais rapidamente. 

Resposta:

• Particionamento: Controla o número de partições em um RDD ou DataFrame. Use o site .repartition() para aumentar ou distribuir uniformemente as partições. Isso é mais caro do ponto de vista computacional e só deve ser usado quando for necessário que os dados sejam divididos igualmente para um processamento equilibrado.
• Coalescente: Reduz o número de partições sem executar um embaralhamento completo, o que é mais eficiente do que reparticionar ao reduzir o número de partições. Para isso, usamos o site .coalesce().

# Increasing partitions (full shuffle)
df_repartitioned = df.repartition(10)
# Reducing partitions (no full shuffle)
df_coalesced = df.coalesce(2)

Observe que uma pergunta de acompanhamento pode mencionar quando essas operações são mais úteis. Não se esqueça de mencionar que eles são mais eficazes ao trabalhar com grandes conjuntos de dados, e que a capacidade de computação não deve ser desperdiçada em conjuntos de dados menores.

15. Explica a interoperabilidade do Spark com formatos de serialização de dados

Os profissionais de dados interagem com uma grande variedade de formatos de dados diferentes. Cada uma dessas opções tem diferentes compensações. Certifique-se de que você possa explicar como o Spark geralmente interage com esses formatos e oferecer desempenho de alto nível, bem como considerações que precisam ser feitas para o ecossistema maior.

1. Suporte ao formato de serialização de dados: O Spark interopera com formatos de serialização de dados, como Avro, Parquet ou ORC, por meio de suporte integrado ou de bibliotecas de terceiros. Esses formatos oferecem vantagens como compactação eficiente, armazenamento em colunas e evolução do esquema, o que os torna adequados para o processamento e o armazenamento de dados em pipelines baseados no Spark.
2. Otimização da leitura de dados: O Spark otimiza as operações de leitura e gravação de dados com esses formatos, utilizando leitores e gravadores especializados que exploram sua estrutura interna e técnicas de compactação. Por exemplo, o Parquet e o ORC aproveitam o armazenamento em colunas para minimizar a sobrecarga de E/S e melhorar o desempenho das consultas.
3. Trocas de formatos de dados: As compensações incluem eficiência de armazenamento (por exemplo, taxa de compactação), desempenho (por exemplo, taxa de transferência de leitura/gravação) e compatibilidade com outras ferramentas de processamento de dados. A escolha do formato de serialização correto depende de fatores como características dos dados, padrões de consulta e requisitos de integração no pipeline de dados.

Perguntas da entrevista sobre codificação do Spark

Essas perguntas de codificação se concentrarão no uso do PySpark para que você possa interagir com um ambiente spark. 

16. Encontre as N palavras mais frequentes em um arquivo de texto grande

Esta pergunta verifica sua capacidade de interagir com o Spark e entender a utilização do mapeamento no próprio Spark.

from pyspark import SparkContext
# create your spark context
sc = SparkContext("local", "WordCount")
# import a text file from a local path
lines = sc.textFile("path/to/your/text/file.txt")
# split and map the words
# then reduce by using the words as keys and add to the count
word_counts = lines.flatMap(lambda line: line.split(" ")) \
                  .map(lambda word: (word, 1)) \
                  .reduceByKey(lambda a, b: a + b)
# order the words and take only the top N frequent words
top_n_words = word_counts.takeOrdered(N, key=lambda x: -x[1])
print(top_n_words)

17. Encontre a média dos valores em um determinado RDD

Essa pergunta é uma ótima maneira de mostrar a você se alguém sabe como criar um RDD simples e manipulá-lo. Encontrar a média dos valores é uma tarefa muito comum dada aos profissionais de dados e é fundamental que você entenda como pegar os dados e formá-los dentro de um contexto Spark.

from pyspark import SparkContext
# Create sparkContext and name it “Average”
sc = SparkContext("local", "Average")
# Generate Spark RDD
data = sc.parallelize([1, 2, 3, 4, 5])
# Sum the RDD, count the number of values in RDD
total_sum = data.sum()
count = data.count()
# divide sum by count to get average 
average = total_sum / count
print("Average:", average)
	

18. Realizar uma união externa esquerda entre dois RDDs

A execução de tarefas de manipulação e transformação de dados, como junções, é um componente essencial do SparkSQL. Isso permite que os dados sejam combinados em diferentes fontes para análise de dados. 

from pyspark import SparkContext
# Create SparkContext
sc = SparkContext("local", "LeftOuterJoin")
# Create two RDDs with tuples sharing keys
rdd1 = sc.parallelize([(1, 'a'), (2, 'b'), (3, 'c')])
rdd2 = sc.parallelize([(1, 'x'), (2, 'y')])
# Use the .leftOuterJoin() method to join the first rdd to the second rdd
joined_rdd = rdd1.leftOuterJoin(rdd2)
# Use the .collect() method to show the rdd
print(joined_rdd.collect())
	

19. Ler dados do Kafka, realizar transformações e, em seguida, gravar os resultados no HDFS

Isso testa a capacidade de você trazer dados de fontes de dados externas e a compreensão de como o Spark pode se conectar a fontes de dados externas. Concentre-se aqui nos conceitos gerais, como a necessidade de importar extensões/utilitários para um determinado fluxo de dados, em vez de memorizar a codificação exata. Observe que, para o SparkContext, optamos por ter um nome de aplicativo (KafkaWordCount) como um parâmetro opcional, mas é bom tê-lo, pois mantém os processos claros.

# Import the sparkcontext, additionally import streaming context and Kafka
from pyspark import SparkContext
from pyspark.streaming import StreamingContext
from pyspark.streaming.kafka import KafkaUtils
# Create context 
sc = SparkContext("local", "KafkaWordCount")
# Use streaming context to bring in data at 10 second intervals
ssc = StreamingContext(sc, 10)  # 10-second batch interval
# Use Kafka param dictionary in order to connect to the stream using the streaming context, the topic of interest, and the parameters
kafka_params = {"metadata.broker.list": "broker1:9092,broker2:9092"}
kafka_stream = KafkaUtils.createDirectStream(ssc, ["topic"], kafka_params)
# save the results of this stream to lines
# perform MapReduce in order to generate dictionary and count by keys
lines = kafka_stream.map(lambda x: x[1])
word_counts = lines.flatMap(lambda line: line.split(" ")) \
                  .map(lambda word: (word, 1)) \
                  .reduceByKey(lambda a, b: a + b)
# save to external file
word_counts.saveAsTextFiles("hdfs://path/to/save")
# start context until you terminate
ssc.start()
ssc.awaitTermination()
	

20. Como você realiza transformações e ações básicas em um DataFrame do Spark?

Essa pergunta avalia a compreensão que o candidato tem das operações de DataFrame no Spark.

As transformações são operações em DataFrames que retornam um novo DataFrame, como selecionar, filtrar e groupBy. As ações são operações que acionam o cálculo e retornam resultados, como show, count e collect.

Esse snippet mostra a seleção de colunas, a filtragem de linhas e a execução de uma agregação group-by.

# Select specific columns
selected_df = df.select("column1", "column2")
# Filter rows based on a condition
filtered_df = df.filter(df["column1"] > 100)
# Group by a column and perform aggregation
grouped_df = df.groupBy("column2").agg({"column1": "sum"})
# Show the results
selected_df.show()
filtered_df.show()
grouped_df.show()

Considerações finais

Dominar essas perguntas de entrevista é um ótimo primeiro passo para você se tornar um profissional de dados. O Spark é uma infraestrutura comum utilizada por muitas organizações para lidar com seus pipelines de big data. Compreender os benefícios e os desafios do Spark ajudará você a se destacar como um profissional de dados experiente. Isso é apenas o começo! A melhor maneira de você aprender é ter experiência prática com o Spark. 

Você pode começar a usar os seguintes cursos e tutoriais sobre PySpark no DataCamp:

• Introdução ao PySpark
• Introdução ao Spark SQL em Python
• Big Data com PySpark
• Tutorial do Apache Spark: ML com PySpark