Apache Spark - Apache Spark

Apache Spark

Autor (es) original (is)	Matei Zaharia
Desenvolvedor (s)	Apache Spark
lançamento inicial	26 de maio de 2014 ; 7 anos atrás ( 26/05/2014 )
Versão estável	3.1.1 / 2 de março de 2021 ; 7 meses atrás ( 2021-03-02 )
Repositório	Repositório Spark
Escrito em	Scala
Sistema operacional	Microsoft Windows , macOS , Linux
Disponível em	Scala , Java , SQL , Python , R , C # , F #
Modelo	Análise de dados, algoritmos de aprendizado de máquina
Licença	Licença Apache 2.0
Local na rede Internet	spark .apache .org

Apache Spark é um mecanismo analítico unificado de código aberto para processamento de dados em grande escala. O Spark fornece uma interface para programar clusters inteiros com paralelismo de dados implícito e tolerância a falhas . Originalmente desenvolvido na University of California, Berkeley 's AMPLab , o código-base Spark foi posteriormente doado para a Apache Software Foundation , que o mantém desde então.

Visão geral

O Apache Spark tem sua base arquitetônica no conjunto de dados distribuído resiliente (RDD), um multiset somente leitura de itens de dados distribuídos em um cluster de máquinas, que é mantido de maneira tolerante a falhas . A API Dataframe foi lançada como uma abstração no topo do RDD, seguida pela API Dataset. No Spark 1.x, o RDD era a interface de programação de aplicativo (API) primária , mas a partir do Spark 2.x, o uso da API Dataset é incentivado, embora a API RDD não seja obsoleta . A tecnologia RDD ainda é a base da API Dataset.

Spark e seus RDDs foram desenvolvidos em 2012 em resposta às limitações do paradigma de computação de cluster MapReduce , que força uma estrutura de fluxo de dados linear específica em programas distribuídos: programas MapReduce lêem dados de entrada do disco, mapeiam uma função nos dados, reduzem os resultados do mapear e armazenar os resultados da redução no disco. Os RDDs do Spark funcionam como um conjunto de trabalho para programas distribuídos que oferece uma forma (deliberadamente) restrita de memória compartilhada distribuída .

Dentro do Apache Spark, o fluxo de trabalho é gerenciado como um gráfico acíclico direcionado (DAG). Os nós representam RDDs enquanto as arestas representam as operações nos RDDs.

O Spark facilita a implementação de algoritmos iterativos , que visitam seu conjunto de dados várias vezes em um loop, e a análise de dados interativa / exploratória, ou seja, a consulta repetida de dados no estilo de banco de dados. A latência de tais aplicativos pode ser reduzida em várias ordens de magnitude em comparação com a implementação do Apache Hadoop MapReduce. Entre a classe de algoritmos iterativos estão os algoritmos de treinamento para sistemas de aprendizado de máquina , que formaram o ímpeto inicial para o desenvolvimento do Apache Spark.

O Apache Spark requer um gerenciador de cluster e um sistema de armazenamento distribuído . Para gerenciamento de cluster, Spark oferece suporte autônomo (cluster Spark nativo, onde você pode iniciar um cluster manualmente ou usar os scripts de inicialização fornecidos pelo pacote de instalação. Também é possível executar esses daemons em uma única máquina para teste), Hadoop YARN , Apache Mesos ou Kubernetes . Para armazenamento distribuído, o Spark pode interagir com uma ampla variedade, incluindo Alluxio , Hadoop Distributed File System (HDFS) , MapR File System (MapR-FS) , Cassandra , OpenStack Swift , Amazon S3 , Kudu , Luster file system ou uma solução personalizada pode ser implementado. O Spark também oferece suporte a um modo local pseudo-distribuído, geralmente usado apenas para fins de desenvolvimento ou teste, onde o armazenamento distribuído não é necessário e o sistema de arquivos local pode ser usado em seu lugar; em tal cenário, o Spark é executado em uma única máquina com um executor por núcleo da CPU .

Spark Core

Spark Core é a base de todo o projeto. Ele fornece despacho de tarefas distribuídas, agendamento e funcionalidades básicas de E / S , expostas por meio de uma interface de programação de aplicativo (para Java , Python , Scala , .NET e R ) centrada na abstração RDD (a API Java está disponível para outras linguagens JVM, mas também pode ser usado para algumas outras linguagens não JVM que podem se conectar à JVM, como Julia ). Essa interface espelha um modelo funcional / de ordem superior de programação: um programa de "driver" invoca operações paralelas, como mapear, filtrar ou reduzir em um RDD, passando uma função para o Spark, que então agenda a execução da função em paralelo no cluster. Essas operações, e outras adicionais, como junções , usam RDDs como entrada e produzem novos RDDs. RDDS são imutáveis e suas operações são preguiçosos ; a tolerância a falhas é alcançada mantendo o controle da "linhagem" de cada RDD (a sequência de operações que o produziu) para que possa ser reconstruído em caso de perda de dados. Os RDDs podem conter qualquer tipo de objeto Python, .NET, Java ou Scala.

Além do estilo de programação funcional orientado para RDD, o Spark fornece duas formas restritas de variáveis ​​compartilhadas: as variáveis ​​de transmissão referem-se a dados somente leitura que precisam estar disponíveis em todos os nós, enquanto os acumuladores podem ser usados ​​para programar reduções em um estilo imperativo .

Um exemplo típico de programação funcional centrada em RDD é o programa Scala a seguir, que calcula as frequências de todas as palavras que ocorrem em um conjunto de arquivos de texto e imprime as mais comuns. Cada mapa , flatMap (uma variante de map ) e reduceByKey assume uma função anônima que executa uma operação simples em um único item de dados (ou um par de itens) e aplica seu argumento para transformar um RDD em um novo RDD.

val conf = new SparkConf().setAppName("wiki_test") // create a spark config object
val sc = new SparkContext(conf) // Create a spark context
val data = sc.textFile("/path/to/somedir") // Read files from "somedir" into an RDD of (filename, content) pairs.
val tokens = data.flatMap(_.split(" ")) // Split each file into a list of tokens (words).
val wordFreq = tokens.map((_, 1)).reduceByKey(_ + _) // Add a count of one to each token, then sum the counts per word type.
wordFreq.sortBy(s => -s._2).map(x => (x._2, x._1)).top(10) // Get the top 10 words. Swap word and count to sort by count.

Spark SQL

Spark SQL é um componente no topo do Spark Core que introduziu uma abstração de dados chamada DataFrames, que fornece suporte para dados estruturados e semiestruturados . Spark SQL fornece uma linguagem específica de domínio (DSL) para manipular DataFrames em Scala , Java , Python ou .NET . Ele também fornece suporte à linguagem SQL, com interfaces de linha de comando e servidor ODBC / JDBC . Embora os DataFrames não tenham a verificação de tipo em tempo de compilação oferecida pelos RDDs, a partir do Spark 2.0, o DataSet fortemente tipado também é totalmente compatível com o Spark SQL.

import org.apache.spark.sql.SparkSession

val url = "jdbc:mysql://yourIP:yourPort/test?user=yourUsername;password=yourPassword" // URL for your database server.
val spark = SparkSession.builder().getOrCreate() // Create a Spark session object

val df = spark
  .read
  .format("jdbc")
  .option("url", url)
  .option("dbtable", "people")
  .load()

df.printSchema() // Looks the schema of this DataFrame.
val countsByAge = df.groupBy("age").count() // Counts people by age

//or alternatively via SQL:
//df.createOrReplaceTempView("people")
//val countsByAge = spark.sql("SELECT age, count(*) FROM people GROUP BY age")

Spark Streaming

O Spark Streaming usa o recurso de agendamento rápido do Spark Core para realizar análises de streaming . Ele ingere dados em minilotes e realiza transformações RDD nesses minilotes de dados. Esse design permite que o mesmo conjunto de código de aplicativo escrito para análise de lote seja usado em análise de streaming, facilitando assim a implementação fácil da arquitetura lambda . No entanto, essa conveniência vem com a penalidade de latência igual à duração do minilote. Outros mecanismos de streaming de dados que processam evento por evento, em vez de minilotes, incluem Storm e o componente de streaming do Flink . Spark Streaming tem suporte integrado para consumir de Kafka , Flume , Twitter , ZeroMQ , Kinesis e soquetes TCP / IP .

No Spark 2.x, uma tecnologia separada baseada em conjuntos de dados, chamada Streams Structured, que possui uma interface de nível superior também é fornecida para suportar streaming.

O Spark pode ser implantado em um data center local tradicional , bem como na nuvem .

Biblioteca de aprendizado de máquina MLlib

Spark MLlib é uma estrutura de aprendizado de máquina distribuída em cima do Spark Core que, devido em grande parte à arquitetura Spark baseada em memória distribuída, é até nove vezes mais rápida que a implementação baseada em disco usada pelo Apache Mahout (de acordo com benchmarks feitos pelos desenvolvedores MLlib contra as implementações de mínimos quadrados alternados (ALS), e antes do próprio Mahout ganhar uma interface Spark), e escala melhor do que o Vowpal Wabbit . Muitos aprendizagem de máquina comum e algoritmos estatísticos foram implementadas e são enviados com MLlib que simplifica a aprendizagem de máquina de grande escala dutos , incluindo:

• estatísticas resumidas , correlações , amostragem estratificada , teste de hipótese , geração de dados aleatórios
• de classificação e de regressão : máquinas de suporte vetor , regressão logística , regressão linear , ingênuo classificação Bayes , Árvore de Decisão , aleatório Floresta , Árvore Gradient-Impulsionado
• técnicas de filtragem colaborativa , incluindo mínimos quadrados alternados (ALS)
• métodos de análise de agrupamento, incluindo k-médias e alocação de Dirichlet latente (LDA)
• técnicas de redução de dimensionalidade , como decomposição de valor singular (SVD) e análise de componente principal (PCA)
• extração de recursos e funções de transformação
• algoritmos de otimização , como descida gradiente estocástica , BFGS de memória limitada (L-BFGS)

GraphX

GraphX ​​é uma estrutura de processamento de gráfico distribuída no topo do Apache Spark. Por ser baseado em RDDs, que são imutáveis, os gráficos são imutáveis ​​e, portanto, o GraphX ​​não é adequado para gráficos que precisam ser atualizados, muito menos de forma transacional como um banco de dados de gráficos . GraphX ​​fornece duas APIs separadas para implementação de algoritmos massivamente paralelos (como PageRank ): uma abstração Pregel e uma API mais geral no estilo MapReduce. Ao contrário de seu predecessor Bagel, que foi formalmente descontinuado no Spark 1.6, GraphX ​​tem suporte total para gráficos de propriedades (gráficos onde as propriedades podem ser anexadas a arestas e vértices).

GraphX ​​pode ser visto como sendo a versão Spark in-memory do Apache Giraph , que utilizou MapReduce baseado em disco do Hadoop.

Como o Apache Spark, o GraphX ​​começou inicialmente como um projeto de pesquisa no AMPLab e no Databricks da UC Berkeley, e mais tarde foi doado à Apache Software Foundation e ao projeto Spark.

Suporte de linguas

O Apache Spark tem suporte integrado para Scala, Java, R e Python com suporte de terceiros para .NET CLR, Julia e muito mais.

História

O Spark foi inicialmente iniciado por Matei Zaharia no UC Berkeley's AMPLab em 2009 e teve o código aberto em 2010 sob uma licença BSD .

Em 2013, o projeto foi doado para a Apache Software Foundation e mudou sua licença para o Apache 2.0 . Em fevereiro de 2014, Spark se tornou um Projeto Apache de nível superior .

Em novembro de 2014, a empresa Databricks do fundador do Spark, M. Zaharia, estabeleceu um novo recorde mundial em classificação em grande escala usando o Spark.

Spark teve mais de 1000 colaboradores em 2015, tornando-o um dos projetos mais ativos na Apache Software Foundation e um dos projetos de big data de código aberto mais ativos .

Desenvolvedores

Apache Spark é desenvolvido por uma comunidade. O projeto é administrado por um grupo denominado "Comitê de Gerenciamento de Projetos" (PMC). O PMC atual é Aaron Davidson, Andy Konwinski, Andrew Or, Ankur Dave, Robert Joseph Evans, DB Tsai, Dongjoon Hyun, Felix Cheung, Hyukjin Kwon, Haoyuan Li, Ram Sriharsha, Holden Karau , Herman van Hövell, Imran Rashid, Jason Dai , Joseph Kurata Bradley, Joseph E. Gonzalez, Josh Rosen, Jerry Shao, Kay Ousterhout, Cheng Lian, Xiao Li, Mark Hamstra, Michael Armbrust, Matei Zaharia , Xiangrui Meng, Nicholas Pentreath, Mosharaf Chowdhury, Mridul Muralidharan, Prashant Sharma, Patrick Wendell, Reynold Xin , Ryan LeCompte, Shane Huang, Shivaram Venkataraman, Sean McNamara, Sean R. Owen, Stephen Haberman, Tathagata Das, Thomas Graves, Thomas Dudziak, Takuya Ueshin, Marcelo Masiero Vanzin, Wenchen Fan, Charles Reiss, Andrew Xia, Yin Huai, Yanbo Liang, Shixiong Zhu.

Veja também

• Lista de APIs / Frameworks de programação simultânea e paralela

Notas

Referências

links externos

• Website oficial