Compartilhar via

Usar o Kit de Ferramentas do Azure para IntelliJ para depurar aplicativos Apache Spark remotamente no HDInsight por meio de VPN

Recomendamos depurar aplicativos Apache Spark remotamente por meio de SSH. Para obter instruções, consulte Depurar remotamente aplicativos Apache Spark em um cluster HDInsight com o Kit de Ferramentas do Azure para IntelliJ por meio do SSH.

Este artigo fornece diretrizes passo a passo sobre como usar as Ferramentas do HDInsight no Azure Toolkit for IntelliJ para enviar um trabalho do Spark em um cluster Spark do HDInsight e depurá-lo remotamente do seu computador desktop. Para concluir essas tarefas, você deve executar as seguintes etapas de alto nível:

  1. Crie uma rede virtual do Azure site a site ou ponto a site. As etapas neste documento pressupõem que você use uma rede site a site.
  2. Crie um cluster Spark no HDInsight que faça parte da rede virtual site a site.
  3. Verifique a conectividade entre o nó principal do cluster e sua área de trabalho.
  4. Crie um aplicativo Scala no IntelliJ IDEA e configure-o para depuração remota.
  5. Execute e depure o aplicativo.

Pré-requisitos

Etapa 1: criar uma rede virtual do Azure

Siga as instruções dos seguintes links para criar uma rede virtual do Azure e verifique a conectividade entre o computador desktop e a rede virtual:

Etapa 2: Criar um cluster SPARK do HDInsight

Recomendamos que você também crie um cluster Apache Spark no Azure HDInsight que faça parte da rede virtual do Azure que você criou. Use as informações disponíveis em Criar clusters baseados em Linux no HDInsight. Como parte da configuração opcional, selecione a rede virtual do Azure que você criou na etapa anterior.

Etapa 3: verificar a conectividade entre o nó principal do cluster e sua área de trabalho

  1. Obtenha o endereço IP do nó de cabeçalho. Abra a interface gráfica do Ambari para o cluster. Na folha do cluster, selecione Painel.

    Selecione Painel no Apache Ambari.

  2. Na interface do usuário do Ambari, selecione Hosts.

    Selecione Hosts no Apache Ambari.

  3. Você verá uma lista de nós principais, nós de trabalho e nós zookeeper. Os nós de cabeçalho têm um prefixo hn*. Selecione o primeiro nó principal.

    Encontre o nó principal no Apache Ambari.

  4. No painel Resumo na parte inferior da página que será aberta, copie o Endereço IP do nó principal e o Nome do host.

    Localize o endereço IP no Apache Ambari.

  5. Adicione o endereço IP e o nome do host do nó de cabeçalho no arquivo hosts no computador do qual você deseja executar e depurar os trabalhos do Spark remotamente. Isso permite que você se comunique com o nó principal usando o endereço IP, bem como o nome do host.

    um. Abra um arquivo do Bloco de Notas com permissões elevadas. No menu Arquivo , selecione Abrir e localize o local do arquivo de hosts. Em um computador Windows, o local é C:\Windows\System32\Drivers\etc\hosts.

    b. Adicione as seguintes informações ao arquivo 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

  6. No computador que você conectou à rede virtual do Azure usada pelo cluster HDInsight, verifique se você pode executar ping nos nós de cabeçalho usando o endereço IP, bem como o nome do host.

  7. Use o SSH para se conectar ao nó principal do cluster seguindo as instruções em Conectar-se a um cluster HDInsight usando SSH. Do nó principal do cluster, execute um ping no endereço IP do computador desktop. Teste a conectividade com os dois endereços IP atribuídos ao computador:

    • Um para a conexão de rede
    • Uma para a rede virtual do Azure

  8. Repita essas etapas no outro nó de cabeçalho.

Etapa 4: Criar um aplicativo Apache Spark Scala usando as Ferramentas do HDInsight no Kit de Ferramentas do Azure para IntelliJ e configurá-lo para depuração remota

  1. Abra o IntelliJ IDEA e crie um novo projeto. Na caixa de diálogo Novo Projeto, faça o seguinte:

    Selecione o novo modelo de projeto no IntelliJ IDEA.

    um. Selecione HDInsight>Spark no HDInsight (Scala).

    b. Selecione Próximo.

  2. Na próxima caixa de diálogo Novo Projeto , faça o seguinte e selecione Concluir:

    • Insira um nome e uma localização para o projeto.

    • Na lista suspensa SDK do Projeto, selecione Java 1.8 para o cluster do Spark 2.x ou selecione Java 1.7 para o cluster do Spark 1.x.

    • Na lista suspensa Versão do Spark, o assistente de criação de projeto Scala integra a versão apropriada do SDK do Spark e do SDK do Scala. Se a versão do cluster do Spark for anterior à 2.0, selecione Spark 1.x. Caso contrário, selecione Spark2.x. Esse exemplo usa o Spark 2.0.2 (Scala 2.11.8).

    Selecione o SDK do projeto e a versão do Spark.

  3. O projeto do Spark cria automaticamente um artefato para você. Para exibir o artefato, faça o seguinte:

    um. No menu Arquivo , selecione Estrutura do Projeto.

    b. Na caixa de diálogo Estrutura do Projeto, selecione Artefatos para exibir o artefato padrão que é criado. Você também pode criar seu próprio artefato selecionando o sinal de adição (+).

    Artefatos do IntelliJ IDEA criam jar.

  4. Adicione bibliotecas ao seu projeto. Para adicionar uma biblioteca, faça o seguinte:

    um. Clique com o botão direito do mouse no nome do projeto na árvore do projeto e selecione Abrir Configurações do Módulo.

    b. Na caixa de diálogo Estrutura do Projeto , selecione Bibliotecas, selecione o símbolo (+) e, em seguida, selecione De Maven.

    Biblioteca de download do IntelliJ IDEA.

    c. Na caixa de diálogo Baixar Biblioteca do Repositório Maven , pesquise e adicione as seguintes bibliotecas:

    • org.scalatest:scalatest_2.10:2.2.1
    • org.apache.hadoop:hadoop-azure:2.7.1

  5. Copie yarn-site.xml e core-site.xml do nó principal do cluster e adicione-os ao projeto. Use os comandos a seguir para copiar os arquivos. Você pode usar o Cygwin para executar os seguintes scp comandos para copiar os arquivos dos nós principais do cluster:

    scp <ssh user name>@<headnode IP address or host name>://etc/hadoop/conf/core-site.xml .

    Como nós já adicionamos o endereço IP e os nomes do host do nó de cabeçalho do cluster para o arquivo hosts na área de trabalho, podemos usar os comandos scp da seguinte maneira:

    scp sshuser@nitinp:/etc/hadoop/conf/core-site.xml .
scp sshuser@nitinp:/etc/hadoop/conf/yarn-site.xml .

    Para adicionar esses arquivos ao projeto, copie-os na pasta /src na árvore do projeto, por exemplo <your project directory>\src.

  6. Atualize o core-site.xml arquivo para fazer as seguintes alterações:

    um. Substitua a chave criptografada. O core-site.xml arquivo inclui a chave criptografada para a conta de armazenamento associada ao cluster. core-site.xml No arquivo que você adicionou ao projeto, substitua a chave criptografada pela chave de armazenamento real associada à conta de armazenamento padrão. Para obter mais informações, confira Gerenciar chaves de acesso da conta de armazenamento.

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

    b. Remova as seguintes 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. Salve o arquivo.

  7. Adicione a classe principal para seu aplicativo. No Gerenciador de Projetos, clique com o botão direito do mouse em src, aponte para Novo e selecione a classe Scala.

    IntelliJ IDEA Selecione a classe principal.

  8. Na caixa de diálogo Criar Nova Classe Scala , forneça um nome, selecione Objeto na caixa Tipo e selecione OK.

    IntelliJ IDEA Criar nova classe Scala.

  9. MyClusterAppMain.scala No arquivo, cole o código a seguir. Esse código cria o contexto do Spark e abre um executeJob método do 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")
    }
}

  10. Repita as etapas 8 e 9 para adicionar um novo objeto Scala chamado *SparkSample. Adicione o código a seguir a essa classe. Esse código lê os dados do HVAC.csv (disponível em todos os clusters spark do HDInsight). Ele recupera as linhas que têm apenas um dígito na sétima coluna no arquivo CSV e grava a saída em /HVACOut no contêiner de armazenamento padrão para o cluster.

    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)
     }
}

  11. Repita as etapas 8 e 9 para adicionar uma nova classe chamada RemoteClusterDebugging. Essa classe implementa a estrutura de teste do Spark usada para depurar os aplicativos. Adicione o código a seguir à classe 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")
     }
    }

    Há algumas coisas importantes a serem observadas:

    • 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"), verifique se o assembly JAR do Spark está disponível no armazenamento de cluster no caminho especificado.
    • Para setJars, especifique o local onde o JAR do artefato é criado. Normalmente, é <Your IntelliJ project directory>\out\<project name>_DefaultArtifact\default_artifact.jar.

  12. Na *RemoteClusterDebugging classe, clique com o botão direito do mouse na test palavra-chave e selecione Criar Configuração de Depuração de Cluster Remoto.

    IntelliJ IDEA Criar uma configuração remota.

  13. Na caixa de diálogo Criar Configuração de Depuração de Cluster Remoto, forneça um nome para a configuração e selecione Tipo de teste como o Nome do teste. Deixe todos os outros valores como as configurações padrão. Selecione Aplicar e selecione OK.

    Criar Configuração de RemoteClusterDebugging.

  14. Agora você deve ver uma lista suspensa de configuração Execução Remota na barra de menus.

    IntelliJ A lista suspensa Execução remota.

Etapa 5: Executar o aplicativo no modo de depuração

  1. Em seu projeto IntelliJ IDEA, abra SparkSample.scala e crie um ponto de interrupção ao lado de val rdd1. No menu pop-up Criar Ponto de Interrupção para, selecione linha na função executeJob.

    IntelliJ IDEA Adicionar um ponto de interrupção.

  2. Para executar o aplicativo, selecione o botão Executar Depuração ao lado da lista suspensa de configuração Execução Remota.

    No IntelliJ IDEA, selecione o botão Executar Depuração.

  3. Quando a execução do programa atingir o ponto de interrupção, você verá uma guia Depurador no painel inferior.

    No IntelliJ IDEA, exiba a guia Depurador.

  4. Para adicionar um relógio, selecione o ícone (+).

    IntelliJ depuração-adicionar-inspeção-variável.

    Neste exemplo, o aplicativo foi quebrado antes da criação da variável rdd1 . Usando este relógio, podemos ver as cinco primeiras linhas na variável rdd. Selecione Enter.

    IntelliJ Execute o programa no modo de depuração.

    O que você vê na imagem anterior é que, em runtime, você pode consultar terabytes de dados e depurar como seu aplicativo progride. Por exemplo, na saída mostrada na imagem anterior, você pode ver que a primeira linha da saída é um cabeçalho. Com base nessa saída, você pode modificar o código do aplicativo para ignorar a linha de cabeçalho, se necessário.

  5. Agora você pode selecionar o ícone Retomar Programa para continuar com a execução do aplicativo.

    No IntelliJ IDEA, selecione Retomar Programa.

  6. Se o aplicativo for concluído com êxito, você deverá ver a saída da seguinte maneira:

    Saída do console do depurador do IntelliJ IDEA.

Próximas etapas

Cenários

Criar e executar aplicativos

Ferramentas e extensões

Gerenciar recursos

  • Last updated on