con - como crear una aplicación en mongodb

¿Mejor práctica para lanzar aplicaciones Spark a través de la aplicación web?

Question

Quiero exponer mis aplicaciones Spark a los usuarios con una aplicación web.

Básicamente, el usuario puede decidir qué acción quiere ejecutar e ingresar algunas variables, que deben pasar a la aplicación de chispa. Por ejemplo: el usuario ingresa algunos campos y luego hace clic en un botón que hace lo siguiente "ejecutar sparkApp1 con el parámetro min_x, max_x, min_y, max_y".

La aplicación de chispa debe iniciarse con los parámetros dados por el usuario. Después de finalizar, la aplicación web puede ser necesaria para recuperar los resultados (de hdfs o mongodb) y mostrarlos al usuario. Durante el procesamiento, la aplicación web debe mostrar el estado de la aplicación Spark.

Mi pregunta:

• ¿Cómo puede la aplicación web lanzar la aplicación Spark? Es posible que pueda iniciarlo desde la línea de comando debajo del capó, pero podría haber una mejor manera de hacerlo.
• ¿Cómo puede la aplicación web acceder al estado actual de la aplicación Spark? ¿Es el camino a seguir el estado de la API REST de Spark WebUI?

Estoy ejecutando un clúster de Spark 1.6.1 con YARN / Mesos (aún no estoy seguro) y MongoDB.

Answer 1

Respuesta muy básica:

Básicamente, puede usar la clase SparkLauncher para iniciar aplicaciones Spark y agregar algunos oyentes para ver el progreso.

Sin embargo, puede estar interesado en el servidor Livy, que es un servidor RESTful para trabajos de Spark. Hasta donde yo sé, Zeppelin está usando Livy para enviar trabajos y recuperar el estado.

También puede usar la interfaz REST de Spark para verificar el estado, la información será más precisa. Here hay un ejemplo de cómo enviar un trabajo a través de REST API

Tiene 3 opciones, la respuesta es: compruebe usted mismo;) Depende mucho de su proyecto y requisitos. Ambas 2 opciones principales:

• Interfaz SparkLauncher + Spark REST
• Servidor Livy

Debe ser bueno para usted y debe verificar qué es más fácil y mejor para usar en su proyecto

Respuesta extendida

Puede usar Spark desde su aplicación de diferentes maneras, según lo que necesite y lo que prefiera.

SparkLauncher

SparkLauncher es una clase del artefacto spark-launcher de spark-launcher . Se utiliza para lanzar trabajos de Spark ya preparados al igual que desde Spark Submit.

El uso típico es:

1) Cree el proyecto con su trabajo de Spark y copie el archivo JAR a todos los nodos 2) Desde su aplicación cliente, es decir, la aplicación web, cree SparkLauncher que apunte al archivo JAR preparado

SparkAppHandle handle = new SparkLauncher()
    .setSparkHome(SPARK_HOME)
    .setJavaHome(JAVA_HOME)
    .setAppResource(pathToJARFile)
    .setMainClass(MainClassFromJarWithJob)
    .setMaster("MasterAddress
    .startApplication();
    // or: .launch().waitFor()

startApplication crea SparkAppHandle que le permite agregar oyentes y detener la aplicación. También ofrece la posibilidad de getAppId .

SparkLauncher debe usarse con la API REST de Spark. Puede consultar http://driverNode:4040/api/v1/applications/*ResultFromGetAppId*/jobs y tendrá información sobre el estado actual de una aplicación.

API REST de Spark

También existe la posibilidad de enviar trabajos de Spark directamente a través de RESTful API. El uso es muy similar al SparkLauncher , pero se realiza de una manera RESTful pura.

Solicitud de ejemplo: créditos para este artículo:

curl -X POST http://spark-master-host:6066/v1/submissions/create --header "Content-Type:application/json;charset=UTF-8" --data ''{
  "action" : "CreateSubmissionRequest",
  "appArgs" : [ "myAppArgument1" ],
  "appResource" : "hdfs:///filepath/spark-job-1.0.jar",
  "clientSparkVersion" : "1.5.0",
  "environmentVariables" : {
    "SPARK_ENV_LOADED" : "1"
  },
  "mainClass" : "spark.ExampleJobInPreparedJar",
  "sparkProperties" : {
    "spark.jars" : "hdfs:///filepath/spark-job-1.0.jar",
    "spark.driver.supervise" : "false",
    "spark.app.name" : "ExampleJobInPreparedJar",
    "spark.eventLog.enabled": "true",
    "spark.submit.deployMode" : "cluster",
    "spark.master" : "spark://spark-cluster-ip:6066"
  }
}''

Este comando enviará el trabajo en la clase ExampleJobInPreparedJar al clúster con Spark Master dado. En la respuesta, tendrá el campo submissionId , que será útil para verificar el estado de la aplicación; simplemente llame a otro servicio: curl http://spark-cluster-ip:6066/v1/submissions/status/submissionIdFromResponse . Eso es todo, nada más que codificar

Livy REST Server y Spark Job Server

Livy REST Server y Spark Job Server son aplicaciones RESTful que le permiten enviar trabajos a través del servicio web RESTful. Una diferencia importante entre esos dos y la interfaz REST de Spark es que Livy y SJS no requieren que los trabajos se preparen antes y se empaqueten en el archivo JAR. Solo está enviando un código que se ejecutará en Spark.

El uso es muy simple. Los códigos se toman del repositorio de Livy, pero con algunos cortes para mejorar la legibilidad

1) Caso 1: envío de trabajo, que se coloca en la máquina local

// creating client
LivyClient client = new LivyClientBuilder()
  .setURI(new URI(livyUrl))
  .build();

try {
  // sending and submitting JAR file
  client.uploadJar(new File(piJar)).get();
  // PiJob is a class that implements Livy''s Job
  double pi = client.submit(new PiJob(samples)).get();
} finally {
  client.stop(true);
}

2) Caso 2: creación y ejecución dinámica de empleos

// example in Python. Data contains code in Scala, that will be executed in Spark
data = {
  ''code'': textwrap.dedent("""/
    val NUM_SAMPLES = 100000;
    val count = sc.parallelize(1 to NUM_SAMPLES).map { i =>
      val x = Math.random();
      val y = Math.random();
      if (x*x + y*y < 1) 1 else 0
    }.reduce(_ + _);
    println(/"Pi is roughly /" + 4.0 * count / NUM_SAMPLES)
    """)
}

r = requests.post(statements_url, data=json.dumps(data), headers=headers)
pprint.pprint(r.json()) 

Como puede ver, son posibles trabajos precompilados y consultas ad-hoc a Spark.

Niebla de la hidrosfera

Otra aplicación de Spark as a Service. Mist es muy simple y similar a Livy y Spark Job Server.

El uso es muy muy similar.

1) Crear archivo de trabajo:

import io.hydrosphere.mist.MistJob

object MyCoolMistJob extends MistJob {
    def doStuff(parameters: Map[String, Any]): Map[String, Any] = {
        val rdd = context.parallelize()
        ...
        return result.asInstance[Map[String, Any]]
    }
} 

2) Paquete de archivo de trabajo en JAR 3) Enviar solicitud a Mist:

curl --header "Content-Type: application/json" -X POST http://mist_http_host:mist_http_port/jobs --data ''{"path": "/path_to_jar/mist_examples.jar", "className": "SimpleContext$", "parameters": {"digits": [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]}, "namespace": "foo"}''

Una cosa fuerte, que puedo ver en Mist, es que tiene soporte inmediato para trabajos de transmisión a través de MQTT .

Apache Toree

Apache Toree fue creado para permitir analíticas interactivas fáciles para Spark. No requiere ningún JAR para ser construido. Funciona a través del protocolo IPython, pero no solo se admite Python.

Actualmente, la documentación se centra en el soporte para portátiles Jupyter, pero también hay una API de estilo REST.

Comparación y conclusiones

He enumerado algunas opciones:

1. SparkLauncher
2. API REST de Spark
3. Livy REST Server y Spark Job Server
4. Niebla de la hidrosfera
5. Apache Toree

Todos ellos son buenos para diferentes casos de uso. Puedo distinguir algunas categorías:

1. Herramientas que requieren archivos JAR con trabajo: Spark Launcher, Spark REST API
2. Herramientas para trabajos interactivos y preempaquetados: Livy, SJS, Mist
3. Herramientas que se centran en analíticas interactivas: Toree (sin embargo, puede haber algún soporte para trabajos preempaquetados; en este momento no se publica documentación)

SparkLauncher es muy simple y es parte del proyecto Spark. Está escribiendo la configuración del trabajo en código plano, por lo que puede ser más fácil de construir que los objetos JSON.

Para un envío de estilo RESTful completo, considere Spark REST API, Livy, SJS y Mist. Tres de ellos son proyectos estables, que tienen algunos casos de uso de producción. REST API también requiere que los trabajos estén preempaquetados y Livy y SJS no. Sin embargo, recuerde que la API REST de Spark está por defecto en cada distribución de Spark y Livy / SJS no. No sé mucho sobre Mist, pero, después de un tiempo, debería ser una herramienta muy buena para integrar todo tipo de trabajos de Spark.

Toree se está centrando en trabajos interactivos. Todavía está en incubación, pero incluso ahora puedes comprobar sus posibilidades.

¿Por qué utilizar un servicio REST personalizado adicional cuando hay una API REST incorporada? SaaS como Livy es un punto de entrada a Spark. Gestiona el contexto de Spark y solo está en un nodo que puede en otro lugar que no sea el clúster. También permiten la analítica interactiva. Apache Zeppelin usa Livy para enviar el código de usuario a Spark

Answer 2

Aquí un ejemplo de SparkLauncher T.Gawęda mencionó:

SparkAppHandle handle = new SparkLauncher()
    .setSparkHome(SPARK_HOME)
    .setJavaHome(JAVA_HOME)
    .setAppResource(SPARK_JOB_JAR_PATH)
    .setMainClass(SPARK_JOB_MAIN_CLASS)
    .addAppArgs("arg1", "arg2")
    .setMaster("yarn-cluster")
    .setConf("spark.dynamicAllocation.enabled", "true")
    .startApplication();

Here puede encontrar un ejemplo de aplicación web java con trabajo Spark incluido en un solo proyecto. A través de SparkLauncher puede obtener SparkAppHandle que puede usar para obtener información sobre el estado del trabajo. Si necesita un estado de progreso, puede usar Spark rest-api :

http://driverHost:4040/api/v1/applications/[app-id]/jobs

La única dependencia que necesitará para SparkLauncher :

<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-launcher_2.10</artifactId>
    <version>2.0.1</version>
</dependency>

Answer 3

Puede usar PredictionIO PredictionIO, un servidor de aprendizaje automático para desarrolladores e ingenieros de ML. https://github.com/apache/predictionio