Desenvolva programas Java MapReduce para o Apache Hadoop no HDInsight

Artigo
06/14/2024

Aprenda a usar o Apache Maven para criar um aplicativo MapReduce baseado em Java e, em seguida, execute-o com o Apache Hadoop no Azure HDInsight.

Pré-requisitos

Java Developer Kit (JDK) versão 8.
Apache Maven corretamente instalado de acordo com o Apache. O Maven é um sistema de construção de projetos para projetos Java.

Configurar o ambiente de desenvolvimento

O ambiente usado para este artigo foi um computador que executa o Windows 10. Os comandos foram executados em um prompt de comando, e os diversos arquivos foram editados com o Bloco de Notas. Modifique de acordo com o seu ambiente.

Em um prompt de comando, digite os comandos abaixo para criar um ambiente de trabalho:

IF NOT EXIST C:\HDI MKDIR C:\HDI
cd C:\HDI

Criar um projeto Maven

Digite o seguinte comando para criar um projeto Maven chamado wordcountjava:
```
mvn archetype:generate -DgroupId=org.apache.hadoop.examples -DartifactId=wordcountjava -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```
Esse comando cria um diretório com o nome especificado pelo parâmetro artifactID (wordcountjava neste exemplo). Este diretório contém os seguintes itens:
- pom.xml – o POM (Modelo de Objeto de Projeto) que contém informações e detalhes de configuração usados para criar o projeto.
- src\main\java\org\apache\hadoop\examples: contém o código do aplicativo.
- src\test\java\org\apache\hadoop\examples: contém testes do aplicativo.
Remova o código de exemplo gerado. Exclua os arquivos de teste e de aplicativo AppTest.java e App.java que foram gerados. Para fazer isso, digite os comandos abaixo:
```
cd wordcountjava
DEL src\main\java\org\apache\hadoop\examples\App.java
DEL src\test\java\org\apache\hadoop\examples\AppTest.java
```

Atualize o modelo do objeto do projeto

Para obter uma referência completa do arquivo pom.xml, consulte https://maven.apache.org/pom.html. Abra o arquivo pom.xml digitando o seguinte comando:

notepad pom.xml

Adicionar dependências

Em pom.xml, adicione o seguinte texto à seção <dependencies>:

<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-mapreduce-examples</artifactId>
    <version>2.7.3</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-mapreduce-client-common</artifactId>
    <version>2.7.3</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-common</artifactId>
    <version>2.7.3</version>
    <scope>provided</scope>
</dependency>

Isso define as bibliotecas necessárias (listadas em <artifactId>) com uma versão específica (listada em <version>). Em tempo de compilação, essa dependência será baixada do repositório padrão do Maven. Você pode usar a pesquisa de repositório do Maven para exibir mais informações.

O <scope>provided</scope> informa o Maven que essas dependências não devem ser empacotadas com o aplicativo, pois são fornecidas pelo cluster do HDInsight em tempo de execução.

Importante

A versão usada deve corresponder à versão do Hadoop no cluster. Para obter mais informações sobre versões, consulte o documento Versão do componente HDInsight.

Configuração de compilação

Plug-ins do Maven permitem que você personalize os estágios de compilação do projeto. Esta seção será usada para adicionar plug-ins, recursos e outras opções de configuração de compilação.

Adicione o código a seguir ao arquivo pom.xml e depois salve e feche o arquivo. Esse texto deve estar dentro das marcas <project>...</project> no arquivo, por exemplo, entre </dependencies> e </project>.

<build>
    <plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>2.3</version>
        <configuration>
        <transformers>
            <transformer implementation="org.apache.maven.plugins.shade.resource.ApacheLicenseResourceTransformer">
            </transformer>
        </transformers>
        </configuration>
        <executions>
        <execution>
            <phase>package</phase>
                <goals>
                <goal>shade</goal>
                </goals>
        </execution>
        </executions>
        </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.6.1</version>
        <configuration>
        <source>1.8</source>
        <target>1.8</target>
        </configuration>
    </plugin>
    </plugins>
</build>

Essa seção configura o Plug-in Compiler do Apache Maven e o Plug-in Shade do Apache Maven. O plug-in compilador é usado para compilar a topologia. O plug-in de tonalidade é usado para evitar a duplicação de licenças no pacote JAR que é criado pelo Maven. O plug-in serve para evitar o erro de arquivos de licença duplicados no momento da execução no cluster do HDInsight. Utilize o plug-in de tonalidade do Maven com a implementação ApacheLicenseResourceTransformer para isso.

O plug-in de tonalidade do Maven também produzirá um uber jar, que contém todas as dependências exigidas pelo aplicativo.

Salve o arquivo pom.xml.

Criar o aplicativo MapReduce

Digite o comando a seguir para criar e abrir um novo arquivo WordCount.java. Selecione Sim no prompt para criar um novo arquivo.
```
notepad src\main\java\org\apache\hadoop\examples\WordCount.java
```

Em seguida, copie e cole o código Java a seguir no novo arquivo. Em seguida, feche o arquivo.

package org.apache.hadoop.examples;

import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

public class WordCount {

    public static class TokenizerMapper
        extends Mapper<Object, Text, Text, IntWritable>{

    private final static IntWritable one = new IntWritable(1);
    private Text word = new Text();

    public void map(Object key, Text value, Context context
                    ) throws IOException, InterruptedException {
        StringTokenizer itr = new StringTokenizer(value.toString());
        while (itr.hasMoreTokens()) {
        word.set(itr.nextToken());
        context.write(word, one);
        }
    }
}

public static class IntSumReducer
        extends Reducer<Text,IntWritable,Text,IntWritable> {
    private IntWritable result = new IntWritable();

    public void reduce(Text key, Iterable<IntWritable> values,
                        Context context
                        ) throws IOException, InterruptedException {
        int sum = 0;
        for (IntWritable val : values) {
        sum += val.get();
        }
        result.set(sum);
        context.write(key, result);
    }
}

public static void main(String[] args) throws Exception {
    Configuration conf = new Configuration();
    String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
    if (otherArgs.length != 2) {
        System.err.println("Usage: wordcount <in> <out>");
        System.exit(2);
    }
    Job job = new Job(conf, "word count");
    job.setJarByClass(WordCount.class);
    job.setMapperClass(TokenizerMapper.class);
    job.setCombinerClass(IntSumReducer.class);
    job.setReducerClass(IntSumReducer.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(IntWritable.class);
    FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
    FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
    System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

Observe que o nome do pacote é org.apache.hadoop.examples e o nome de classe é WordCount. Você usará esses nomes quando enviar o trabalho MapReduce.

Compilar e criar o pacote do aplicativo

Use o diretório wordcountjava, use o comando a seguir para compilar um arquivo JAR que contém o aplicativo:

mvn clean package

Esse comando limpa quaisquer artefatos de criação anteriores, baixa quaisquer dependências que ainda não foram instaladas e, então, compila o aplicativo e cria seu pacote.

Quando o comando é concluído, o diretório wordcountjava/target contém um arquivo chamado wordcountjava-1.0-SNAPSHOT.jar.

Observação

O arquivo wordcountjava-1.0-SNAPSHOT.jar é um uberjar, que contém não apenas o trabalho WordCount, mas também as dependências necessárias para o trabalho em runtime.

Carregue o arquivo JAR e execute trabalhos (SSH)

As etapas a seguir usam scp para copiar o JAR para o nó principal primário de seu Apache HBase no cluster HDInsight. Então, o comando ssh será utilizado para se conectar ao cluster e executar o exemplo diretamente no nó principal.

Carregue o jar no cluster. Substitua CLUSTERNAME pelo nome do cluster HDInsight e, em seguida, digite o seguinte comando:
```
scp target/wordcountjava-1.0-SNAPSHOT.jar sshuser@CLUSTERNAME-ssh.azurehdinsight.net:
```
Conecte-se ao cluster. Substitua CLUSTERNAME pelo nome do cluster HDInsight e, em seguida, digite o seguinte comando:
```
ssh sshuser@CLUSTERNAME-ssh.azurehdinsight.net
```
Na sessão do SSH, use o seguinte comando para executar o aplicativo MapReduce:
```
yarn jar wordcountjava-1.0-SNAPSHOT.jar org.apache.hadoop.examples.WordCount /example/data/gutenberg/davinci.txt /example/data/wordcountout
```
Esse comando inicia o aplicativo WordCount MapReduce. O arquivo de entrada é /example/data/gutenberg/davinci.txt, e o diretório de saída é /example/data/wordcountout. Os arquivos de entrada e saída são armazenados no armazenamento padrão do cluster.
Quando o trabalho for concluído, use o seguinte comando para exibir os resultados:
```
hdfs dfs -cat /example/data/wordcountout/*
```
Você deverá receber uma lista de palavras e contagens, com valores semelhantes ao seguinte texto:
```
zeal    1
zelus   1
zenith  2
```

Próximas etapas

Neste documento, você aprendeu a desenvolver um trabalho MapReduce em Java. Consulte os seguintes documentos para ver outras maneiras de trabalhar com o HDInsight.

Compartilhar via