O que são os comandos Spark Shell?
O shell Spark é uma interface usada para escrever consultas ad-hoc para trabalhar e entender o comportamento do Apache Spark. É chamado de mecanismo de código aberto de computação em cluster, que pode processar dados na memória, como para análise, ETL, aprendizado de máquina para grandes conjuntos de dados. Neste tópico, vamos aprender sobre os comandos Spark Shell.
Existem vários tipos de shell Spark para diferentes linguagens de programação, por exemplo:
- spark-shell está escrito em Scala
- O pyspark está em Python e
- sparkR para a linguagem R
Pode-se desenvolver seu aplicativo independente com a ajuda do Spark. É amplamente utilizado devido à sua velocidade computacional super-rápida. Isso ocorre porque ele usa o MapReduce para processar várias consultas e transformações.
Para executar comandos spark-shell, é necessário que o Java e o Scala já estejam instalados no sistema.
Tipos de comandos do Spark Shell
Os vários tipos de comandos Spark-shell são os seguintes:
1. Para verificar se o Spark está instalado e para conhecer sua versão, abaixo do comando, é usado (Todos os comandos a seguir serão indicados começando com este símbolo "$")
$ concha de faísca
A seguinte saída será exibida se o spark estiver instalado:
$ concha de faísca
SPARK_MAJOR_VERSION está definido como 2, usando Spark2
Definindo o nível de log padrão como "WARN".
Para ajustar o nível de log, use sc.setLogLevel (newLevel). Para o SparkR, use setLogLevel (newLevel).
Interface do usuário da Web de contexto do Spark disponível em http://10.113.59.34:4040
Contexto do Spark disponível como 'sc' (mestre = local (*), ID do aplicativo = local-1568732886588).
Sessão Spark disponível como 'spark'.
Bem-vindo ao
____ __
/ __ / __ ___ _____ / / __
_ \ \ / _ \ / _ `/ __ / '_ /
/ ___ / .__ / \ _, _ / _ / / _ / \ _ \ versão 2.2.0.2.6.3.0-235
/ _ /
Usando o Scala versão 2.11.8 (VM do servidor Java HotSpot (TM) de 64 bits, Java 1.8.0_112)
Digite expressões para que sejam avaliadas.
Digite: help para mais informações.
scala>
2. A estrutura de dados básica do Spark é chamada de RDD (Resilient Distributed Datasets), que contém uma coleção imutável de objetos para computação distribuída de registros. Todos os conjuntos de dados do RDD são particionados logicamente em vários nós de um cluster.
Um RDD pode ser criado apenas pela leitura de um sistema de arquivos local ou pela transformação de um RDD existente.
a) Para criar um novo RDD, usamos o seguinte comando:
scala> val examplefile = sc.textFile("file.txt")
Aqui sc é chamado de objeto do SparkContext.
Resultado:
examplefile: org.apache.spark.rdd.RDD(String) = file.txt MapPartitionsRDD(3) at textFile at :24
b) Um RDD pode ser criado através da Parallelized Collection da seguinte maneira:
scala> val oddnum = Array(1, 3, 5, 7, 9)
Resultado:
oddnum: Array(Int) = Array(1, 3, 5, 7, 9)
scala> val value = sc.parallelize(oddnum)
Resultado:
value: org.apache.spark.rdd.RDD(Int) = ParallelCollectionRDD(4) at parallelize at :26
c) Para criar a partir de RDDs existentes :
scala> val newRDD = oddnum.map(value => (value * 2))
Resultado:
newRDD: Array(Int) = Array(2, 6, 10, 14, 18)
3. Existem dois tipos de Operações Spark RDD que podem ser executadas nos conjuntos de dados criados:
- Ações
- Transformações
Ações: É usado para executar determinadas operações necessárias nos conjuntos de dados existentes. A seguir, estão alguns dos comandos que podem ser usados para executar as ações abaixo nos conjuntos de dados criados:
a) função count () para contar o número de elementos no RDD:
scala> value.count()
Resultado:
res3: Long = 5
b) função collect () para exibir todos os elementos da matriz:
scala> value.collect()
Resultado:
res5: Array(Int) = Array(1, 3, 5, 7, 9)
c) função first () usada para exibir o primeiro elemento do conjunto de dados:
scala> value.first()
Resultado:
res4: Int = 1
d) A função take (n) exibe os primeiros n elementos da matriz:
scala> value.take(3)
Resultado:
res6: Array(Int) = Array(1, 3, 5)
e) A função takeSample (withReplacement, num, (seed)) exibe uma matriz aleatória de elementos "num" onde a semente é para o gerador de números aleatórios.
scala> value.takeSample(false, 3, System.nanoTime.toInt)
Resultado:
res8: Array(Int) = Array(3, 1, 7)
f) A função saveAsTextFile (path) salva o conjunto de dados no caminho especificado da localização dos hdfs
scala> value.saveAsTextFile("/user/valuedir")
g) partições. A função length pode ser usada para encontrar o número de partições no RDD
scala> value.partitions.length
Resultado:
res1: Int = 8
Transformações RDD
A transformação é usada para formar um novo RDD a partir dos já existentes. Como as entradas do RDD são imutáveis, o resultado formado na transformação pode ser um ou mais RDD como saída.
Existem dois tipos de transformações:
- Transformações estreitas
- Grandes transformações
Transformações estreitas - Cada RDD pai é dividido em várias partições e dentre essas, apenas uma partição será usada pelo RDD filho.
Exemplo: map () e filter () são os dois tipos básicos de transformações básicas que são chamadas quando uma ação é chamada.
- A função map (func) opera em cada um dos elementos no “valor” do conjunto de dados iterativamente para produzir o RDD de saída.
Exemplo: neste exemplo, estamos adicionando o valor 10 a cada um dos elementos do valor do conjunto de dados e exibindo a saída transformada com a ajuda da função de coleta.
scala> val mapfunc = value.map(x => x+10)
mapfunc: org.apache.spark.rdd.RDD(Int) = MapPartitionsRDD(3) at map at :28
scala> mapfunc.collect
res2: Array(Int) = Array(11, 13, 15, 17, 19)
A função filter (func) é basicamente usada para filtrar os elementos que satisfazem uma condição específica especificada usando a função
Exemplo: neste exemplo, estamos tentando recuperar todos os elementos, exceto o número 2 do conjunto de dados "value" e buscando a saída por meio da função de coleta.
scala> val fill = value.filter(x => x!=2)
fill: org.apache.spark.rdd.RDD(Int) = MapPartitionsRDD(7) at filter at :28
scala> fill.collect
res8: Array(Int) = Array(4, 6, 8, 10)
Transformações amplas - Uma partição RDD de pai único é compartilhada em suas várias partições filho múltiplas de RDD.
Exemplo: groupbykey e replacebyKey são exemplos de amplas transformações.
- A função groupbyKey agrupa os valores do conjunto de dados em pares de valores-chave de acordo com os valores-chave de outro RDD. Esse processo envolve o embaralhamento quando o grupo por função coleta os dados associados a uma chave específica e os armazena em um único par de valores-chave.
Exemplo: neste exemplo, estamos atribuindo os números inteiros 5, 6 ao valor da string "chave" e o número inteiro 8 atribuído a "8" que são exibidos no mesmo formato de par de valores-chave na saída.
scala> val data = spark.sparkContext.parallelize(Array(("key", 5), ("val", 8), ("key", 6)), 3)
data: org.apache.spark.rdd.RDD((String, Int)) = ParallelCollectionRDD(13) at parallelize at :23
scala> val group = data.groupByKey().collect()
group: Array((String, Iterable(Int))) = Array((key, CompactBuffer(5, 6)), (val, CompactBuffer(8)))
scala> group.foreach(println)
(key, CompactBuffer(5, 6))
(val, CompactBuffer(8))
- A função reduzirByKey também combina os pares de valores-chave de diferentes RDDs. Combina as chaves e seus respectivos valores em um único elemento após executar a transformação mencionada.
Exemplo: Neste exemplo, as teclas comuns da matriz "letras" são paralelizadas pela função e cada letra é mapeada com a contagem 10. O reduzaByKey adicionará os valores com chaves semelhantes e salva na variável value2. A saída é exibida usando a função de coleta.
scala> val letters = Array("A", "B", "C", "D", "B", "C", "E", "D")
letters: Array(String) = Array(A, B, C, D, B, C, E, D)
scala> val value2 = spark.sparkContext.parallelize(letters).map(w => (w, 10)).reduceByKey(_+_)
value2: org.apache.spark.rdd.RDD((String, Int)) = ShuffledRDD(20) at reduceByKey at :25
scala> value2.foreach(println)
(C, 20)
(E, 10)
(D, 20)
(B, 20)
(A, 10)
Juntamente com as ações mencionadas acima, como particionar para RDD e executar ações / transformações nelas, o Spark também suporta cache, o que é útil quando os mesmos dados estão sendo chamados recursivamente.
Com a ajuda de todas essas propriedades, o Apache Spark pode processar grandes volumes de dados e executar processamento em lote e processamento de streaming. O cálculo na memória feito pelo Spark é responsável pelo processamento extremamente rápido dos aplicativos. Portanto, o Spark é o método obrigatório devido à sua versatilidade de programação em diferentes idiomas, facilidade de uso e recursos de integração.
Artigos recomendados
Este é um guia para os comandos Spark Shell. Aqui discutimos os vários tipos de comandos do Spark Shell para diferentes linguagens de programação. Você também pode consultar o seguinte artigo para saber mais -
- Comandos de script de shell
- Como instalar o Spark
- Perguntas da entrevista do Spark
- Comandos do Spark
- Teste Adhoc
- Gerador de número aleatório em JavaScript
- Guia para a lista de comandos do Unix Shell
- PySpark SQL | Módulos e métodos do PySpark SQL
- For Loop em scripts de shell | Como o loop funciona?
- Comandos de script em lote com exemplos
- Visão geral completa dos componentes Spark