Scala for Backend Engineering & Functional Programming · Aula

RDDs e DataFrames

Abstrações de dados do Spark.

RDDs e DataFrames é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que é o Apache Spark?

Apache Spark é um mecanismo distribuído para processamento de dados em grande escala. Ele divide os dados entre um cluster e executa os cálculos em paralelo. Scala é a linguagem nativa do Spark, oferecendo uma API concisa e consciente dos tipos.

O RDD

O conjunto de dados distribuído resiliente (RDD) é a abstração de baixo nível do Spark: uma coleção imutável e particionada que pode ser processada em paralelo e reconstruída a partir da linhagem caso um nó falhe.

SparkContext e SparkSession

Você entra no Spark por meio de uma SparkSession. O sparkContext dela cria RDDs; a própria sessão cria DataFrames e executa SQL.

import org.apache.spark.sql.SparkSession

val spark = SparkSession.builder()
  .appName("Demo")
  .master("local[*]")
  .getOrCreate()

Criando um RDD

Crie um RDD paralelizando uma coleção local ou lendo um arquivo. Cada partição é processada por uma tarefa separada.

val sc = spark.sparkContext
val numbers = sc.parallelize(Seq(1, 2, 3, 4, 5))
val lines   = sc.textFile("data.txt")

O DataFrame

Um DataFrame é uma tabela distribuída com colunas nomeadas e tipadas — como um RDD de linhas acompanhado de um esquema. O otimizador Catalyst pode planejar e otimizar consultas de DataFrame.

Criando um DataFrame

Crie DataFrames a partir de coleções (com toDF) ou lendo arquivos estruturados, como CSV, JSON ou Parquet.

import spark.implicits._

val df = Seq(("Alice", 30), ("Bob", 25)).toDF("name", "age")
val csv = spark.read.option("header", "true").csv("people.csv")

Inspecionando um DataFrame

Use show para imprimir linhas, printSchema para visualizar os tipos das colunas e count para obter o número de linhas.

df.printSchema()
df.show()
println(df.count())

Conjuntos de dados e segurança de tipos

Um conjunto de dados é um DataFrame tipado: Dataset[T], em que T é uma classe de caso. Ele combina a otimização de DataFrame com verificações de tipos em tempo de compilação.

import spark.implicits._

case class Person(name: String, age: Int)
val ds = Seq(Person("Alice", 30)).toDS()

RDD versus DataFrame versus Dataset

Escolha com base nas suas necessidades:

RDD — controle total, sem esquema e sem otimizador
DataFrame — esquema e otimização do Catalyst, com linhas não tipadas
Dataset — esquema, otimização e segurança de tipos

Convertendo entre eles

Converta um DataFrame em um RDD com .rdd ou um RDD de classes de caso em um DataFrame com .toDF. Os Datasets também são convertidos em DataFrames com .toDF.

val rdd = df.rdd          // DataFrame -> RDD[Row]
val back = ds.toDF()      // Dataset -> DataFrame

Coleção Scala simples

Conceitualmente, um DataFrame se comporta como uma coleção Scala, mas distribuída. Veja aqui o equivalente local e autocontido para entender melhor.

object Main {
  case class Person(name: String, age: Int)
  def main(args: Array[String]): Unit = {
    val people = Seq(Person("Alice", 30), Person("Bob", 25))
    people.foreach(p => println(s"${p.name}: ${p.age}"))
  }
}

Verificação rápida

Qual abstração fornece um esquema, a otimização do Catalyst e segurança de tipos em tempo de compilação?

Recapitulação

Você conheceu as abstrações de dados do Spark:

SparkSession como ponto de entrada
RDD — coleção distribuída de baixo nível
DataFrame — tabela distribuída com esquema
Dataset — DataFrame tipado

A seguir: transformações e ações.

Perguntas Frequentes

A aula “RDDs e DataFrames” é grátis?

Sim — o texto completo de “RDDs e DataFrames” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “RDDs e DataFrames”?

Abstrações de dados do Spark. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “RDDs e DataFrames”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming