Hadoop实战教程

# Hadoop实战教程

## 什么是Hadoop

Hadoop是一个分布式计算框架，可以用来存储和处理大规模数据。它的核心组件包括HDFS和MapReduce。

HDFS是Hadoop分布式文件系统的缩写，是Hadoop用来存储数据的主要组件。它可以将大规模的数据分散在多台服务器上，提高了数据的可靠性和可扩展性。

MapReduce是Hadoop的计算模型，可以用来处理存储在HDFS中的大规模数据集。MapReduce将任务分成两个部分：Map和Reduce。Map任务负责将输入数据转换为一组中间键值对，Reduce任务则将这些中间键值对合并并生成最终的输出结果。

## Hadoop安装

以下是Hadoop在Linux环境下的安装步骤：

1. 下载Hadoop

   在Hadoop的官网（https://hadoop.apache.org/）上下载最新版本的Hadoop，并解压到合适的目录。

2. 配置环境变量

   打开.bashrc文件，并在其中添加以下配置：

   ```bash
   export HADOOP_HOME=/path/to/hadoop
   export PATH=$PATH:$HADOOP_HOME/bin
   ```

   然后使用source命令使配置生效：

   ```bash
   source ~/.bashrc
   ```

3. 配置Hadoop

   进入Hadoop目录，并编辑etc/hadoop/hadoop-env.sh文件。将其中的JAVA_HOME配置为您的Java安装路径。

   ```bash
   export JAVA_HOME=/path/to/java
   ```

   接着编辑etc/hadoop/core-site.xml文件，添加以下内容：

   ```xml
   <configuration>
     <property>
       <name>fs.defaultFS</name>
       <value>hdfs://localhost:9000</value>
     </property>
   </configuration>
   ```

   这个配置告诉Hadoop默认使用HDFS，并将HDFS的地址设置为localhost:9000。

   接着编辑etc/hadoop/hdfs-site.xml文件，添加以下内容：

   ```xml
   <configuration>
     <property>
       <name>dfs.replication</name>
       <value>1</value>
     </property>
     <property>
       <name>dfs.namenode.name.dir</name>
       <value>file:/path/to/hadoop_data/hdfs/namenode</value>
     </property>
     <property>
       <name>dfs.datanode.data.dir</name>
       <value>file:/path/to/hadoop_data/hdfs/datanode</value>
     </property>
   </configuration>
   ```

   这个配置设置了HDFS的一些参数，比如复制因子（这里设置为1），以及HDFS存储数据的路径。

   最后，编辑etc/hadoop/mapred-site.xml文件，添加以下内容：

   ```xml
   <configuration>
     <property>
       <name>mapreduce.framework.name</name>
      

21. 在Hadoop集群中运行MapReduce作业

上面的操作，我们已经搭建好了一个Hadoop集群，现在我们来看如何在集群中运行一个MapReduce作业。

首先，我们需要准备好一个MapReduce作业的源代码，这里以WordCount为例。WordCount是一个经典的MapReduce作业，用于统计文本中每个单词出现的次数。

代码如下：

```
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;

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();
        Job job = Job.getInstance(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(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}
```

将代码保存到本地，并将其打包成jar包。可以使用以下命令进行打包：

```
$ javac -classpath $(hadoop classpath) -d wordcount_classes WordCount.java
$ jar -cvf wordcount.jar -C wordcount_classes/ .
```

将打包好的jar包上传到Hadoop集群上，可以使用以下命令将文件从本地上传到Hadoop集群：

```
$ hdfs dfs -put /path/to/local/file /path/to/hdfs
```

接着，我们需要在Hadoop集群上启动MapReduce作业。可以使用以下命令进行启动：

```
$ hadoop jar /path/to/wordcount.jar WordCount /path/to/input/dir /path/to/output/dir
```

其中，`/path/to/wordcount.jar`为打包好的jar包的路径，`WordCount`为MapReduce作业的类名，`/path/to

十八、Hadoop集群配置

1. Hadoop集群的搭建

Hadoop是分布式的大数据处理框架，集群部署是Hadoop的核心内容。在这里，我们将介绍如何搭建一个Hadoop集群。这里我们假设你已经有了多个可用的机器，并且每个机器上都已经安装好了Hadoop。

2. 修改hosts文件

为了让各个节点能够互相访问，需要在每个节点的/etc/hosts文件中添加其他节点的IP和主机名。例如：

```
192.168.0.101 hadoop01
192.168.0.102 hadoop02
192.168.0.103 hadoop03
```

需要保证每个节点都添加了其他节点的信息。

3. 配置SSH免密码登录

为了方便节点之间的文件传输和命令执行，我们需要配置SSH免密码登录。具体的配置步骤如下：

（1）生成公钥和私钥

在每个节点上运行以下命令，生成公钥和私钥：

```
ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa
```

其中，-t参数指定密钥类型，-P参数指定密钥的密码（此处为空），-f参数指定生成密钥文件的路径和文件名。

（2）将公钥添加到其他节点的authorized_keys文件中

在每个节点上运行以下命令，将公钥添加到其他节点的authorized_keys文件中：

```
cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
```

其中，~/.ssh/id_rsa.pub是生成的公钥文件，~/.ssh/authorized_keys是存储SSH公钥的文件。

（3）测试SSH连接

在每个节点上运行以下命令，测试节点之间的SSH连接：

```
ssh hadoop01
```

如果连接成功，会出现以下提示：

```
The authenticity of host 'hadoop01 (192.168.0.101)' can't be established.
RSA key fingerprint is ...
Are you sure you want to continue connecting (yes/no)?
```

输入yes确认连接，即可成功连接到其他节点。

4. 配置Hadoop集群

（1）配置hadoop-env.sh文件

在每个节点上，修改Hadoop的配置文件hadoop-env.sh，将JAVA_HOME设置为JDK的安装路径。例如：

```
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
```

（2）配置core-site.xml文件

在每个节点上，修改Hadoop的配置文件core-site.xml，设置Hadoop的默认文件系统为HDFS，并指定NameNode的地址。例如：

```
<configuration>
    <property>
        <name>fs.defaultFS</name>
        <value>hdfs://hadoop01:9000</value>
    </property>
</configuration>
```