¿Qué son los comandos de Spark Shell?
Spark Shell es una interfaz utilizada para escribir consultas ad hoc para trabajar y comprender el comportamiento de Apache Spark. Se llama el motor de código abierto de computación en clúster que puede procesar datos en la memoria, como análisis, ETL, aprendizaje automático para grandes conjuntos de datos. En este tema, vamos a aprender sobre los comandos de Spark Shell.
Existen varios tipos de shell Spark para diferentes lenguajes de programación, por ejemplo:
- spark-shell está escrito en Scala
- pyspark está en Python y
- sparkR para lenguaje R
Uno puede desarrollar su aplicación independiente con la ayuda de Spark. Es ampliamente utilizado debido a su velocidad computacional súper rápida. Esto se debe a que utiliza MapReduce para procesar varias consultas y transformaciones.
Para ejecutar los comandos de spark-shell, requiere que Java y Scala ya estén instalados en el sistema.
Tipos de comandos de Spark Shell
Los diversos tipos de comandos de Spark-shell son los siguientes:
1. Para verificar si Spark está instalado y para conocer su versión, se utiliza el siguiente comando (Todos los comandos a continuación se indicarán comenzando con este símbolo "$")
$ spark-shell
La siguiente salida se muestra si la chispa está instalada:
$ spark-shell
SPARK_MAJOR_VERSION se establece en 2, usando Spark2
Establecer el nivel de registro predeterminado en "WARN".
Para ajustar el nivel de registro, use sc.setLogLevel (newLevel). Para SparkR, use setLogLevel (newLevel).
Interfaz de usuario web de contexto de Spark disponible en http://10.113.59.34:4040
El contexto de Spark está disponible como 'sc' (master = local (*), id de aplicación = local-1568732886588).
Sesión de chispa disponible como 'chispa'.
Bienvenido a
____ __
/ __ / __ ___ _____ / / __
_ \ \ / _ \ / _ `/ __ / '_ /
/ ___ / .__ / \ _, _ / _ / / _ / \ _ \ versión 2.2.0.2.6.3.0-235
/ _ /
Uso de Scala versión 2.11.8 (Java HotSpot (TM) VM de servidor de 64 bits, Java 1.8.0_112)
Escriba expresiones para evaluarlas.
Tipo: ayuda para más información.
scala>
2. La estructura básica de datos de Spark se denomina RDD (conjuntos de datos distribuidos resilientes) que contiene una colección inmutable de objetos para la computación distribuida de registros. Todos los conjuntos de datos de RDD están particionados lógicamente en múltiples nodos de un clúster.
Un RDD solo se puede crear leyendo un sistema de archivos local o transformando un RDD existente.
a) Para crear un nuevo RDD usamos el siguiente comando:
scala> val examplefile = sc.textFile("file.txt")
Aquí sc se llama el objeto de SparkContext.
Salida:
examplefile: org.apache.spark.rdd.RDD(String) = file.txt MapPartitionsRDD(3) at textFile at :24
b) Se puede crear un RDD a través de la Colección paralela de la siguiente manera:
scala> val oddnum = Array(1, 3, 5, 7, 9)
Salida:
oddnum: Array(Int) = Array(1, 3, 5, 7, 9)
scala> val value = sc.parallelize(oddnum)
Salida:
value: org.apache.spark.rdd.RDD(Int) = ParallelCollectionRDD(4) at parallelize at :26
c) Para crear desde RDD existentes :
scala> val newRDD = oddnum.map(value => (value * 2))
Salida:
newRDD: Array(Int) = Array(2, 6, 10, 14, 18)
3. Hay dos tipos de operaciones Spark RDD que se pueden realizar en los conjuntos de datos creados:
- Comportamiento
- Transformaciones
Acciones: se utiliza para realizar ciertas operaciones requeridas en los conjuntos de datos existentes. Los siguientes son algunos de los comandos que se pueden usar para realizar las siguientes acciones en los conjuntos de datos creados:
a) cuenta () función para contar el número de elementos en RDD:
scala> value.count()
Salida:
res3: Long = 5
b) función collect () para mostrar todos los elementos de la matriz:
scala> value.collect()
Salida:
res5: Array(Int) = Array(1, 3, 5, 7, 9)
c) función first () utilizada para mostrar el primer elemento del conjunto de datos:
scala> value.first()
Salida:
res4: Int = 1
d) la función take (n) muestra los primeros n elementos de la matriz:
scala> value.take(3)
Salida:
res6: Array(Int) = Array(1, 3, 5)
e) La función takeSample (withReplacement, num, (seed)) muestra una matriz aleatoria de elementos "num" donde la semilla es para el generador de números aleatorios.
scala> value.takeSample(false, 3, System.nanoTime.toInt)
Salida:
res8: Array(Int) = Array(3, 1, 7)
f) La función saveAsTextFile (ruta) guarda el conjunto de datos en la ruta especificada de la ubicación hdfs
scala> value.saveAsTextFile("/user/valuedir")
g) particiones. La función de longitud se puede utilizar para encontrar el número de particiones en el RDD
scala> value.partitions.length
Salida:
res1: Int = 8
Transformaciones RDD
La transformación se utiliza para formar un nuevo RDD a partir de los existentes. Como las entradas del RDD son inmutables, el resultado formado tras la transformación puede ser uno o más RDD como salida.
Hay dos tipos de transformaciones:
- Transformaciones estrechas
- Amplias transformaciones
Transformaciones estrechas: cada RDD principal se divide en varias particiones y, entre ellas, el RDD secundario solo utilizará una partición.
Ejemplo: map () y filter () son los dos tipos básicos de transformaciones básicas que se llaman cuando se llama a una acción.
- La función map (func) opera en cada uno de los elementos en el "valor" del conjunto de datos de forma iterativa para producir el RDD de salida.
Ejemplo: en este ejemplo, estamos agregando el valor 10 a cada uno de los elementos del valor del conjunto de datos y mostrando la salida transformada con la ayuda de la función de recopilación.
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)
La función filter (func) se utiliza básicamente para filtrar los elementos que satisfacen una condición particular especificada mediante la función.
Ejemplo: en este ejemplo, estamos tratando de recuperar todos los elementos excepto el número 2 del "valor" del conjunto de datos y obtener la salida a través de la función de recopilación.
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)
Transformaciones anchas : una partición RDD principal única se comparte en sus varias particiones RDD secundarias múltiples.
Ejemplo: groupbykey y reducebyKey son ejemplos de transformaciones amplias.
- La función groupbyKey agrupa los valores del conjunto de datos en pares clave-valor de acuerdo con los valores clave de otro RDD. Este proceso implica la combinación aleatoria que tiene lugar cuando el grupo por función recolecta los datos asociados con una clave particular y los almacena en un solo par clave-valor.
Ejemplo: en este ejemplo, estamos asignando los enteros 5, 6 al valor de cadena "clave" y el entero 8 asignado a "8" que se muestran en el mismo formato de par clave-valor en la salida.
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))
- La función reduceByKey también combina los pares clave-valor de diferentes RDD. Combina las claves y sus valores respectivos en un solo elemento después de realizar la transformación mencionada.
Ejemplo: en este ejemplo, las teclas comunes de la matriz "letras" primero se paralelizan por la función y cada letra se asigna con el recuento 10. ReduceByKey agregará los valores que tengan claves similares y guardará en la variable value2. La salida se muestra usando la función de recopilación.
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)
Junto con las acciones mencionadas anteriormente, como particionar en RDD y realizar acciones / transformaciones en ellas, Spark también admite el almacenamiento en caché, que es útil cuando los mismos datos se llaman de forma recursiva.
Con la ayuda de todas estas propiedades, Apache Spark puede procesar grandes volúmenes de datos y realizar procesamiento por lotes y procesamiento de transmisión. El cálculo en memoria realizado por Spark es responsable del procesamiento extremadamente rápido de las aplicaciones. Por lo tanto, Spark es el método de acceso debido a su versatilidad de programación en diferentes lenguajes, facilidad de uso y capacidades de integración.
Artículos recomendados
Esta es una guía de los comandos de Spark Shell. Aquí discutimos los diversos tipos de comandos de Spark Shell para diferentes lenguajes de programación. También puede consultar el siguiente artículo para obtener más información:
- Comandos de script de shell
- Cómo instalar Spark
- Preguntas de la entrevista de Spark
- Comandos de chispa
- Prueba ad hoc
- Generador de números aleatorios en JavaScript
- Guía de la lista de comandos de shell de Unix
- PySpark SQL | Módulos y métodos de PySpark SQL
- Para secuencias de comandos de bucle en shell | ¿Cómo funciona el bucle?
- Comandos de secuencias de comandos por lotes con ejemplos
- Descripción completa de los componentes de Spark