Uso del kit de herramientas de Azure para IntelliJ para depurar aplicaciones de Apache Spark de forma remota en HDInsight a través de VPN

2025-06-22

Se recomienda depurar aplicaciones de Apache Spark de forma remota a través de SSH. Para obtener instrucciones, consulte Depurar remotamente aplicaciones de Apache Spark en un clúster de HDInsight utilizando Azure Toolkit para IntelliJ mediante SSH.

En este artículo se proporcionan instrucciones paso a paso sobre cómo usar las herramientas de HDInsight del kit de herramientas de Azure para IntelliJ para enviar un trabajo de Spark en un clúster de HDInsight Spark y, a continuación, depurarlo de forma remota desde el equipo de escritorio. Para completar estas tareas, debe realizar los siguientes pasos generales:

Cree una red virtual de Azure de sitio a sitio o de punto a sitio. En los pasos de este documento se supone que usa una red de sitio a sitio.
Cree un clúster de Spark en HDInsight que forme parte de la red virtual de sitio a sitio.
Compruebe la conectividad entre el nodo principal del clúster y el escritorio.
Cree una aplicación de Scala en IntelliJ IDEA y configúrela para la depuración remota.
Ejecute y depure la aplicación.

Prerrequisitos

Una suscripción de Azure.
Un clúster de Apache Spark en HDInsight. Para obtener instrucciones, vea Crear clústeres Apache Spark en HDInsight de Azure.
Kit de desarrollo de Java de Oracle. Puede instalarlo desde el sitio web de Oracle.
IntelliJ IDEA. En este artículo se usa la versión 2017.1. Puede instalarlo desde el Sitio web de JetBrains.
Herramientas de HDInsight en el kit de herramientas de Azure para IntelliJ. Las herramientas de HDInsight para IntelliJ están disponibles como parte del kit de herramientas de Azure para IntelliJ. Para obtener instrucciones sobre cómo instalar El kit de herramientas de Azure, consulte Instalación del kit de herramientas de Azure para IntelliJ.
Inicie sesión en su suscripción de Azure desde IntelliJ IDEA. Siga las instrucciones de Uso del kit de herramientas de Azure para IntelliJ para crear aplicaciones de Apache Spark para un clúster de HDInsight.
Solución alternativa de excepciones. Al ejecutar la aplicación Spark Scala para la depuración remota en un equipo Windows, es posible que obtenga una excepción. Esta excepción se explica en SPARK-2356 y se produce debido a que falta un archivo WinUtils.exe en Windows. Para solucionar este error, debe descargar Winutils.exe en una ubicación como C:\WinUtils\bin. Agregue una variable de entorno HADOOP_HOME y, a continuación, establezca el valor de la variable en C\WinUtils.

Paso 1: Creación de una red virtual de Azure

Siga las instrucciones de los vínculos siguientes para crear una red virtual de Azure y, a continuación, compruebe la conectividad entre el equipo de escritorio y la red virtual:

Paso 2: Creación de un clúster de HDInsight Spark

Se recomienda crear también un clúster de Apache Spark en Azure HDInsight que forme parte de la red virtual de Azure que creó. Use la información disponible en Creación de clústeres basados en Linux en HDInsight. Como parte de la configuración opcional, seleccione la red virtual de Azure que creó en el paso anterior.

Paso 3: Comprobar la conectividad entre el nodo principal del clúster y el escritorio

Obtenga la dirección IP del nodo principal. Abra la interfaz de usuario de Ambari para el clúster. En la hoja del clúster, seleccione Panel.
En la interfaz de usuario de Ambari, seleccione Hosts.
Verá una lista de nodos principales, nodos de trabajo y nodos de zookeeper. Los nodos principales tienen un prefijo hn*. Seleccione el primer nodo principal.
En el panel Resumen de la parte inferior de la página que se abre, copie la dirección IP del nodo principal y el nombre de host.
Agregue la dirección IP y el nombre de host del nodo principal al archivo de hosts en el equipo donde desea ejecutar y depurar de forma remota el trabajo de Spark. Esto le permite comunicarse con el nodo principal mediante la dirección IP, así como el nombre de host.

a) Abra un archivo del Bloc de notas con permisos elevados. En el menú Archivo , seleccione Abrir y busque la ubicación del archivo hosts. En un equipo Windows, la ubicación es C:\Windows\System32\Drivers\etc\hosts.

b. Agregue la siguiente información al archivo de hosts :
```
# For headnode0
192.xxx.xx.xx nitinp
192.xxx.xx.xx nitinp.lhwwghjkpqejawpqbwcdyp3.gx.internal.cloudapp.net

# For headnode1
192.xxx.xx.xx nitinp
192.xxx.xx.xx nitinp.lhwwghjkpqejawpqbwcdyp3.gx.internal.cloudapp.net
```
Desde el equipo que ha conectado a la red virtual de Azure que usa el clúster de HDInsight, compruebe que puede hacer ping a los nodos principales mediante la dirección IP, así como el nombre de host.
Use SSH para conectarse al nodo principal del clúster siguiendo las instrucciones de Conexión a un clúster de HDInsight mediante SSH. En el nodo principal del clúster, haga ping a la dirección IP del equipo de escritorio. Pruebe la conectividad a ambas direcciones IP asignadas al equipo:
- Una para la conexión de red
- Una para la red virtual de Azure
Repita los pasos para el otro nodo principal.

Paso 4: Creación de una aplicación de Apache Spark Scala mediante herramientas de HDInsight en el kit de herramientas de Azure para IntelliJ y configuración para la depuración remota

Abra IntelliJ IDEA y cree un nuevo proyecto. En el cuadro de diálogo Nuevo proyecto , haga lo siguiente:

a) Seleccione HDInsight>Spark en HDInsight (Scala).

b. Seleccione Siguiente.
En el siguiente cuadro de diálogo Nuevo proyecto , haga lo siguiente y seleccione Finalizar:
- Escriba un nombre de proyecto y una ubicación.
- En la lista desplegable SDK de Project, seleccione Java 1.8 para el clúster de Spark 2.x o seleccione Java 1.7 para el clúster de Spark 1.x.
- En la lista desplegable Versión de Spark , el Asistente para la creación de proyectos de Scala integra la versión adecuada para el SDK de Spark y el SDK de Scala. Si la versión del clúster de Spark es anterior a 2.0, seleccione Spark 1.x. De lo contrario, seleccione Spark2.x. En este ejemplo se usa Spark 2.0.2 (Scala 2.11.8).
El proyecto de Spark crea automáticamente un artefacto. Para ver el artefacto, haga lo siguiente:

a) En el menú Archivo , seleccione Estructura del proyecto.

b. En el cuadro de diálogo Estructura del proyecto, seleccione Artefactos para ver el artefacto predeterminado que se ha creado. También puede crear su propio artefacto seleccionando el signo más (+).
Agregue bibliotecas al proyecto. Para agregar una biblioteca, haga lo siguiente:

a) Haga clic con el botón derecho en el nombre del proyecto en el árbol del proyecto y seleccione Abrir configuración del módulo.

b. En el cuadro de diálogo Estructura del proyecto , seleccione Bibliotecas, seleccione el símbolo (+) y, a continuación, seleccione Desde Maven.

c. En el cuadro de diálogo Descargar biblioteca del repositorio de Maven , busque y agregue las bibliotecas siguientes:
- org.scalatest:scalatest_2.10:2.2.1
- org.apache.hadoop:hadoop-azure:2.7.1
Copie yarn-site.xml y core-site.xml desde el nodo principal del clúster y agréguelos al proyecto. Use los siguientes comandos para copiar los archivos. Puede usar Cygwin para ejecutar los siguientes scp comandos para copiar los archivos de los nodos principales del clúster:
```
scp <ssh user name>@<headnode IP address or host name>://etc/hadoop/conf/core-site.xml .
```
Dado que ya hemos agregado la dirección IP del nodo principal del clúster y los nombres de host para el archivo de hosts en el escritorio, podemos usar los scp comandos de la siguiente manera:
```
scp sshuser@nitinp:/etc/hadoop/conf/core-site.xml .
scp sshuser@nitinp:/etc/hadoop/conf/yarn-site.xml .
```
Para agregar estos archivos al proyecto, cópielos en la carpeta /src del árbol del proyecto, por ejemplo <your project directory>\src.

Actualice el core-site.xml archivo para realizar los cambios siguientes:

a) Reemplace la clave cifrada. El core-site.xml archivo incluye la clave cifrada en la cuenta de almacenamiento asociada al clúster. En el core-site.xml archivo que agregó al proyecto, reemplace la clave cifrada por la clave de almacenamiento real asociada a la cuenta de almacenamiento predeterminada. Para obtener más información, consulte Administración de las claves de acceso de la cuenta de almacenamiento.

<property>
        <name>fs.azure.account.key.hdistoragecentral.blob.core.windows.net</name>
        <value>access-key-associated-with-the-account</value>
</property>

b. Quite las siguientes entradas de core-site.xml:

<property>
        <name>fs.azure.account.keyprovider.hdistoragecentral.blob.core.windows.net</name>
        <value>org.apache.hadoop.fs.azure.ShellDecryptionKeyProvider</value>
</property>

<property>
        <name>fs.azure.shellkeyprovider.script</name>
        <value>/usr/lib/python2.7/dist-packages/hdinsight_common/decrypt.sh</value>
</property>

<property>
        <name>net.topology.script.file.name</name>
        <value>/etc/hadoop/conf/topology_script.py</value>
</property>

c. Guarde el archivo.

Agregue la clase principal para tu aplicación. En el Explorador de proyectos, haga clic con el botón derecho en src, seleccione Nuevo y, a continuación, seleccione Clase Scala.
En el cuadro de diálogo Crear nueva clase de Scala , proporcione un nombre, seleccione Objeto en el cuadro Tipo y, a continuación, seleccione Aceptar.

En el MyClusterAppMain.scala archivo, pegue el código siguiente. Este código crea el contexto de Spark y abre un executeJob método a partir del SparkSample objeto .

import org.apache.spark.{SparkConf, SparkContext}

object SparkSampleMain {
    def main (arg: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SparkSample")
                                .set("spark.hadoop.validateOutputSpecs", "false")
    val sc = new SparkContext(conf)

    SparkSample.executeJob(sc,
                        "wasb:///HdiSamples/HdiSamples/SensorSampleData/hvac/HVAC.csv",
                        "wasb:///HVACOut")
    }
}

Repita los pasos 8 y 9 para agregar un nuevo objeto Scala denominado *SparkSample. Agregue el siguiente código a esta clase. Este código lee los datos de la HVAC.csv (disponible en todos los clústeres de HDInsight Spark). Recupera las filas que solo tienen un dígito en la séptima columna del archivo CSV y, a continuación, escribe la salida en /HVACOut en el contenedor de almacenamiento predeterminado para el clúster.

import org.apache.spark.SparkContext

object SparkSample {
    def executeJob (sc: SparkContext, input: String, output: String): Unit = {
    val rdd = sc.textFile(input)

    //find the rows which have only one digit in the 7th column in the CSV
    val rdd1 =  rdd.filter(s => s.split(",")(6).length() == 1)

    val s = sc.parallelize(rdd.take(5)).cartesian(rdd).count()
    println(s)

    rdd1.saveAsTextFile(output)
    //rdd1.collect().foreach(println)
     }
}

Repita los pasos 8 y 9 para agregar una nueva clase denominada RemoteClusterDebugging. Esta clase implementa el marco de pruebas de Spark que se usa para depurar las aplicaciones. Agregue el siguiente código a la clase RemoteClusterDebugging:

    import org.apache.spark.{SparkConf, SparkContext}
    import org.scalatest.FunSuite

    class RemoteClusterDebugging extends FunSuite {

     test("Remote run") {
       val conf = new SparkConf().setAppName("SparkSample")
                                 .setMaster("yarn-client")
                                 .set("spark.yarn.am.extraJavaOptions", "-Dhdp.version=2.4")
                                 .set("spark.yarn.jar", "wasb:///hdp/apps/2.4.2.0-258/spark-assembly-1.6.1.2.4.2.0-258-hadoop2.7.1.2.4.2.0-258.jar")
                                 .setJars(Seq("""C:\workspace\IdeaProjects\MyClusterApp\out\artifacts\MyClusterApp_DefaultArtifact\default_artifact.jar"""))
                                 .set("spark.hadoop.validateOutputSpecs", "false")
       val sc = new SparkContext(conf)

       SparkSample.executeJob(sc,
         "wasb:///HdiSamples/HdiSamples/SensorSampleData/hvac/HVAC.csv",
         "wasb:///HVACOut")
     }
    }

Hay un par de cosas importantes que debe tener en cuenta:

Para .set("spark.yarn.jar", "wasb:///hdp/apps/2.4.2.0-258/spark-assembly-1.6.1.2.4.2.0-258-hadoop2.7.1.2.4.2.0-258.jar"), asegúrese de que el archivo JAR del ensamblado de Spark está disponible en el almacenamiento del clúster en la ubicación especificada.
En setJars, especifique la ubicación donde se crea el archivo JAR del artefacto. Normalmente, es <Your IntelliJ project directory>\out\<project name>_DefaultArtifact\default_artifact.jar.

En la*RemoteClusterDebugging clase, haga clic con el botón derecho en la test palabra clave y, a continuación, seleccione Crear configuración de RemoteClusterDebugging.
En el cuadro de diálogo Crear configuración RemoteClusterDebugging, proporcione un nombre para la configuración y, a continuación, seleccione Tipo de prueba como Test name. Deje todos los demás valores como la configuración predeterminada. Seleccione Aplicar y luego Aceptar.
Ahora debería ver una lista desplegable de "configuración de ejecución remota" en la barra de menús.

Paso 5: Ejecución de la aplicación en modo de depuración

En el proyecto IntelliJ IDEA, abra SparkSample.scala y cree un punto de interrupción junto a val rdd1. En el menú emergente Crear punto de interrupción para, seleccione línea en la función executeJob.
Para ejecutar la aplicación, seleccione el botón Depurar ejecutar situado junto a la lista desplegable Configuración de ejecución remota.
Cuando la ejecución del programa alcanza el punto de interrupción, verá una pestaña Depurador en el panel inferior.
Para agregar un reloj, seleccione el icono (+).

En este ejemplo, la aplicación se rompió antes de crear la variable rdd1 . Con este reloj, podemos ver las cinco primeras filas de la variable rdd. Seleccione Escriba.

Lo que ve en la imagen anterior es que, durante el tiempo de ejecución, podría consultar terabytes de datos y depurar cómo progresa su aplicación. Por ejemplo, en la salida que se muestra en la imagen anterior, puede ver que la primera fila de la salida es un encabezado. En función de esta salida, puede modificar el código de la aplicación para omitir la fila de encabezado, si es necesario.
Ahora puede seleccionar el icono Reanudar programa para continuar con la ejecución de la aplicación.
Si la aplicación finaliza correctamente, debería ver una salida similar a la siguiente: