¿Cómo configurar Windows para compilar un proyecto con Apache Spark Code sin instalarlo?

Apache Spark es un motor de análisis unificado y se utiliza para procesar datos a gran escala. Apache Spark proporciona la funcionalidad para conectarse con otros lenguajes de programación como Java, Python, R, etc. mediante el uso de API. Proporciona una manera fácil de configurar con otro IDE para realizar nuestras tareas según sus requisitos. Admite herramientas como Spark SQL para SQL, GraphX ​​para procesamiento de gráficos, MLlib para Machine Learning, etc. 

En esto, verá cómo podemos configurar Scala IDE para ejecutar el código Apache Spark. Y podrá aprender a configurar Spark Project en Scala IDE sin instalar explícitamente Hadoop y Spark en su sistema. Discutiremos cada paso en detalle y podrá configurar con estos pasos. Además, cubriremos la dependencia requerida para configurar, y también cubriremos qué requisitos previos se requerirán para configurar Scala IDE. Aquí discutiremos e implementaremos todos los pasos en Scala IDE. Pero estos pasos también pueden ser seguidos por cualquier otro IDE. Si desea configurar esto en Eclipse IDE, Eclipse IDE también puede seguir los mismos pasos. 

Introducción

• Spark es un marco de procesamiento de Big Data distribuido de código abierto desarrollado por AMPLab , la Universidad de California en 2009.
• Más tarde, Spark fue donado a Apache Software Foundation. Ahora, es mantenido por la Fundación Apache.
• Spark es el principal motor de procesamiento de Big Data, que es un lenguaje de programación escrito de Scala.
• Inicialmente, había un modelo de procesamiento MapReduce (basado en el lenguaje de programación Java) en Hadoop.
• Spark Framework es compatible con los lenguajes de programación Java, Scala, Python y R.

Según el tipo de datos y la funcionalidad, Spark tiene una API diferente para procesar de la siguiente manera: 

• El componente básico de Spark es Spark core.
• Spark proporciona SparkSQL para el análisis de datos estructurados y semiestructurados que se basa en DataFrame y Dataset.
• Para Streaming Data, Spark tiene API de Spark Streaming.
• Para implementar el algoritmo de aprendizaje automático , Spark proporciona MLib, es decir, el marco de aprendizaje automático distribuido.
• Los datos de gráficos se pueden procesar de manera efectiva con GraphX, es decir, el marco de procesamiento de gráficos distribuidos.

SparkSQL, Spark Streaming, MLib y GraphX ​​se basan en la funcionalidad principal de Spark y en el concepto de RDD, es decir , conjunto de datos distribuido resistente . RDD es una colección inmutable de conjuntos de datos de partición distribuida, que se almacena en Nodes de datos en el clúster de Hadoop.

Requisito previo :

1. Java. Asegúrese de tener Java instalado en su sistema.
2. Scala IDE/Eclipse/Intellij IDEA: puede usar cualquiera de estos, cualquiera que le resulte familiar. Aquí, verá Scala IDE para su referencia.

Paso 1: crear un proyecto Maven

Crear un proyecto maven es muy simple. Siga los pasos a continuación para crear un proyecto.

• Haga clic en la pestaña del menú Archivo -> Nuevo -> Otro
• Haga clic en Proyecto Maven . Aquí, en este paso, haga clic en la casilla de verificación » Crear un proyecto simple (omitir selección de archtipo) «, luego haga clic en » Siguiente> «
• Agregue el Id. de grupo y el Id. de artefacto , luego haga clic en » Finalizar «

Con esto, ha creado con éxito un proyecto Java con Maven. Ahora, la siguiente acción es agregar una dependencia para Spark. 

Paso 2: agregar la dependencia de Spark requerida en pom.xml

Simplemente puede encontrar el archivo pom.xml en su proyecto maven recién creado y agregar a continuación la dependencia Spark (spark-core, spark-sql). Estas versiones de dependencias se pueden cambiar según las necesidades del proyecto. 

Nota: Puede ver la dependencia 2.4.0 agregada de Spark-core y spark-sql. La versión Spark 3.0.1 también está disponible, puede agregar la dependencia según su versión de Spark en el clúster y según los requisitos de su proyecto.

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  
 <modelVersion>4.0.0</modelVersion>
 <groupId>java.spark</groupId>
 <artifactId>Spark-Learning</artifactId>
 <version>0.0.1-SNAPSHOT</version>
  
 <dependencies>
  
 <dependency>
  <groupId>com.thoughtworks.paranamer</groupId>
  <artifactId>paranamer</artifactId>
  <version>2.8</version>
 </dependency>
  
 <dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-core_2.12</artifactId>
  <version>2.4.0</version>
 </dependency>
  
 <dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-sql_2.12</artifactId>
  <version>2.4.0</version>
 </dependency>
  
</dependencies>
  
</project>

Paso 3: escribir código de muestra de Spark

Ahora, ya casi has terminado. Simplemente cree un paquete con el nombre spark.java dentro de su proyecto. Luego, dentro del paquete recién creado, cree una clase Java SparkReadCSV. Como no tenemos Hadoop instalado en el sistema, aún podemos simplemente descargar el archivo winutils y agregar esa ruta como una ruta del directorio de inicio de Hadoop. 

Aquí hay algunos pasos que requerimos para hacer esto.

• Descargue el archivo winutils.exe. https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-winutils/2.4.1
• Cree un directorio Hadoop\bin en su disco. Aquí, en mi caso, he creado la carpeta Hadoop\bin dentro de D: Drive.
• Copie el archivo winutils.exe en la carpeta D:\\hadoop\\bin.
• Por último, en el archivo SparkReadCSV.java, agregue el directorio de inicio de Hadoop a la ruta anterior. Me gusta esto de la siguiente manera.

System.setProperty("hadoop.home.dir", "D:\\Hadoop\\");

Cree un archivo employee.txt y agregue los siguientes registros ficticios.

Agregue el siguiente código al archivo SparkReadCSV.java . Puede consultar el siguiente código con comentarios muy descriptivos para una mejor comprensión.

Código:

package spark.java;
  
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;
  
public class SparkReadCSV {
  
    public static void main(String[] args)
    {
  
        // Set winutils.exe file path
  
        System.setProperty("hadoop.home.dir",
                           "D:\\Hadoop\\");
  
        // Create a SparkSession object to process the data
        // Function builder() used for creating SparkSession
          
        // object
        // Function appName() set a name for the application
        // which will be show in YARN/Spark web UI.
  
        // Function master() set a spark master URL to run
        // application, such "local" to run locally OR
  
        // "local[3]" to run with 3 cores OR "yarn-cluster"
        //  to run on YARN Hadoop cluster.
  
        // Function getOrCreate() return a Spark session to
        // execute application.
        SparkSession spark
            = SparkSession
                  .builder()
                  .appName("***** Reading CSV file.*****")
                  .master("local[3]")
                  .getOrCreate();
  
        // Read sample CSV file.
  
        // Read used to read data as a DataFrame.
  
        // The boolean value in option function indicate that
        // input data first line is header.
  
        // The delimiter value("|") in option indicate that
        // files records are | separated.
  
        // function csv() is accept input data file path
        // either from Local File System OR Hadoop Distributed
        // File System.
        
        // Here we are reading data from Local File System.
        Dataset<Row> employeeDS
            = spark
                  .read()
                  .option("header", true)
                  .option("delimiter", "|")
                  .csv("D:\\data\\employee.txt");
  
        // Displaying the records.
        employeeDS.show();
    }
}

Hemos configurado un entorno de desarrollo de Spark con unos pocos pasos sencillos. Con este punto de partida, podemos explorar más a fondo Spark resolviendo diferentes casos de uso.