分别阐述hdfs,yarn,zookeeper,kafka

原创

mob649e81543e41 2023-07-21 09:49:52 ©著作权

文章标签 apache hadoop HDFS 文章分类 Yarn 大数据

©著作权归作者所有：来自51CTO博客作者mob649e81543e41的原创作品，请联系作者获取转载授权，否则将追究法律责任

HDFS, YARN, ZooKeeper, Kafka 详解

在大数据领域中，HDFS、YARN、ZooKeeper和Kafka 是一些重要的技术组件。本文将详细介绍这些组件并提供相应的代码示例。

HDFS (Hadoop Distributed File System)

HDFS 是一个高可靠性、高可扩展性、容错性强的分布式文件系统。它被设计用于在大型集群上存储和处理大规模数据。

HDFS 提供了一种将大文件拆分成多个块，并在集群的多个节点上分布存储这些块的机制。这种分布式存储方式使得在集群中并行处理和访问数据成为可能。

以下是一个简单的代码示例，用于演示如何使用 HDFS 进行文件操作：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

public class HDFSExample {
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        conf.set("fs.defaultFS", "hdfs://localhost:9000");
        
        FileSystem fs = FileSystem.get(conf);
        
        // 在 HDFS 上创建一个目录
        fs.mkdirs(new Path("/mydir"));
        
        // 在 HDFS 上创建一个文件并写入内容
        Path filePath = new Path("/myfile.txt");
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(fs.create(filePath)));
        writer.write("Hello, HDFS!");
        writer.close();
        
        // 从 HDFS 上读取文件内容
        BufferedReader reader = new BufferedReader(new InputStreamReader(fs.open(filePath)));
        String line = reader.readLine();
        System.out.println(line);
        reader.close();
        
        // 删除 HDFS 上的文件
        fs.delete(filePath, true);
        
        // 删除 HDFS 上的目录
        fs.delete(new Path("/mydir"), true);
        
        fs.close();
    }
}

YARN (Yet Another Resource Negotiator)

YARN 是一个负责资源管理和任务调度的集群管理系统。它是 Hadoop 的第二代资源管理框架，为各种应用程序提供了一个统一的资源管理和调度平台。

YARN 将集群的资源划分为容器，并为不同的应用程序分配和管理这些容器。这种资源管理方式使得不同类型的应用程序可以共享集群资源，并提供了更好的资源利用率和任务调度效果。

以下是一个简单的代码示例，用于演示如何使用 YARN 提交一个 MapReduce 任务：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;

public class YARNExample {
    public static class MyMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();
        
        public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String line = value.toString();
            String[] words = line.split(" ");
            
            for (String w : words) {
                word.set(w);
                context.write(word, one);
            }
        }
    }
    
    public static class MyReducer 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(YARNExample.class);
        job.setMapperClass(MyMapper.class);
        job.setCombinerClass(MyReducer.class);
        job.setReducerClass(MyReducer.class);
        
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        
        FileInputFormat.addInputPath(job, new Path("/input"));
        FileOutputFormat.setOutputPath(job, new Path("/output"));
        
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}