Hadoop_12_Mapreduce

最新推荐文章于 2023-11-13 11:19:56 发布
最新推荐文章于 2023-11-13 11:19:56 发布
阅读量175 收藏
点赞数
文章标签： hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Latterain/article/details/106381258
版权

Mapreduce增强

自定义groupingCompatator实现分组求topN

订单产品价格
Order_0000001Pdt_01222.8
Order_0000001Pdt_0525.8
Order_0000002Pdt_03522.8
Order_0000002Pdt_04122.4
Order_0000002Pdt_05722.4
Order_0000003Pdt_01222.8

求取每给订单当中，金额最大的那个商品的价格是多少

输出：分组求top1
Order_0000001 Pdt_01 222.8

Order_0000002 Pdt_05 722.4

Order_0000003 Pdt_01 222.8

过MR实现分组求top1
第一个问题：求金额的最大值，要排序，按照金额来进行排序
可以将金额做成k2

第二个问题：如何区分不同的订单?
通过订单id来区分我们不同的订单，相同的订单，发送到同一个reduce里面去，形成一个集合
需要将订单号作为k2

因此，我们需要

  1. 将订单号orderId和金额price同时作为k2，封装到一个javaBean中；实现比较和序列化：extends WritableComparable
  2. 重写分区规则，按照订单号进行分区；
  3. 重写排序规则，按照金额进行排序。
  4. 重写分组策略：分组合并相同的key，分组需要仅以javaBean中的订单号作为key，将value数据放入同一个集合里面去。
    定义类：WritableComparator

程序实现

OrderBean

如果是求最大值，则将compareTo方法的排序return值改为**-i**，即可实现。
如果是求最小值，compareTo方法的排序return值则为i

package demo6;

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class OrderBean implements WritableComparable<OrderBean>{
    private String orderId;
    private Double price;


    @Override
    public int compareTo(OrderBean o) {
        //需要先比较订单Id是否相同，如果订单ID相同再比较价格
        int i = this.orderId.compareTo(o.orderId);
        if (i == 0) {
            //按照价格进行排序
            i = this.price.compareTo(o.price);
            return i;
        }
        return i;
    }
    //序列化
    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeUTF(orderId);
        dataOutput.writeDouble(price);
    }
    //反序列化
    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.orderId = dataInput.readUTF();
        this.price = dataInput.readDouble();
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return orderId+"\t"+price;
    }
}

Mapper

package demo6;

import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class GroupMapper extends Mapper<LongWritable,Text, OrderBean, DoubleWritable> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] split = value.toString().split("\t");
        OrderBean orderBean = new OrderBean();
        orderBean.setOrderId(split[0]);
        orderBean.setPrice(Double.valueOf(split[2]));
        DoubleWritable doubleWritable = new DoubleWritable();
        context.write(orderBean,doubleWritable);
    }
}

Partition

package demo6;

import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Partitioner;

public class GroupPartition extends Partitioner<OrderBean, DoubleWritable> {
    //仿照HashPartitioner写

    @Override
    public int getPartition(OrderBean orderBean, DoubleWritable doubleWritable, int i) {
        /**
         *
         * @param orderBean : k2
         * @param doubleWritable : v2
         * @param i : numPartitions
         */
        return (orderBean.getOrderId().hashCode() & 2147483647) % i;
    }
}

Comparator

package demo6;

import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;

public class GroupComparator extends WritableComparator {
    //重写默认的无参构造器，定义我们反射出来的对象时OrderBean这个类
    public  GroupComparator(){
        super(OrderBean.class,true);
    }

    @Override
    public int compare(WritableComparable a, WritableComparable b) {
        OrderBean first = (OrderBean) a;
        OrderBean second = (OrderBean) b;
        return first.getOrderId().compareTo(second.getOrderId());
    }
}

Reducer

package demo6;

import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

public class GroupReducer extends Reducer<OrderBean, DoubleWritable, OrderBean, DoubleWritable> {
    @Override
    protected void reduce(OrderBean key, Iterable<DoubleWritable> values, Context context) throws IOException, InterruptedException {
        int i = 0;
        for (DoubleWritable value : values) {
            i++;
            if (i <= 2) {
                context.write(key, value);
            }else {
                break;
            }
        }
    }
}

Main

package demo6;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.NullWritable;
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.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class GroupMain extends Configured implements Tool {

    @Override
    public int run(String[] strings) throws Exception {
        Job job = Job.getInstance(super.getConf(), "group");

        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path("file:///C:\\Users\\Yichun\\Desktop\\hadoop\\hadoop_05\\自定义groupingComparator\\input"));

        job.setMapperClass(GroupMapper.class);
        job.setMapOutputKeyClass(OrderBean.class);
        job.setMapOutputValueClass(DoubleWritable.class);

        job.setPartitionerClass(GroupPartition.class);

        //自定义分组类
        job.setGroupingComparatorClass(GroupComparator.class);

        job.setReducerClass(GroupReducer.class);
        job.setOutputKeyClass(OrderBean.class);
        job.setOutputValueClass(DoubleWritable.class);

        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job,new Path("file:///C:\\Users\\Yichun\\Desktop\\hadoop\\hadoop_05\\自定义groupingComparator\\outputN"));

        boolean b = job.waitForCompletion(true);

        return b?0:1;
    }

    public static void main(String[] args) throws Exception {
        int run = ToolRunner.run(new Configuration(), new GroupMain(), args);
        System.exit(run);
    }
}

分区与分组的关系

分区：主要是决定了我们的数据去往哪一个reduce
分组：决定了哪些数据分到一个组里面去，形成一个集合，一起调用一次reduce逻辑
如果不经过分组，就会是1357135这样的顺序一次次调用。经过分组就可以111调用一次
在这里插入图片描述

mapreduce参数优化

在这里插入图片描述

资源相关参数

在mapred-site.xml配置文件：

  1. mapreduce.map.memory.mb: 一个Map Task可使用的资源上限（单位:MB），默认为1024。如果Map Task实际使用的资源量超过该值，则会被强制杀死。
  2. mapreduce.reduce.memory.mb: 一个Reduce Task可使用的资源上限（单位:MB），默认为1024。如果Reduce Task实际使用的资源量超过该值，则会被强制杀死。
  3. mapred.child.java.opts 配置每个map或者reduce使用的内存的大小，默认是200M
  4. mapreduce.map.cpu.vcores: 每个Map task可使用的最多cpu core数目, 默认值: 1
  5. mapreduce.reduce.cpu.vcores: 每个Reduce task可使用的最多cpu core数目, 默认值: 1
    虚拟内核：根据我们CPU的型号，CPU的类型，虚拟出来的一些核数
    i7 8代 的CPU 1个实体核可以虚拟出来8个虚拟内核

//shuffle性能优化的关键参数，应在yarn启动之前就配置好

  1. mapreduce.task.io.sort.mb 100 //shuffle的环形缓冲区大小，默认100m
  2. mapreduce.map.sort.spill.percent 0.8 //环形缓冲区溢出的阈值，默认80%

在yarn-site.xml配置文件

  1. yarn.scheduler.minimum-allocation-mb 1024 给应用程序container分配的最小内存
  2. yarn.scheduler.maximum-allocation-mb 8192 给应用程序container分配的最大内存
  3. yarn.scheduler.minimum-allocation-vcores 1 container最小的虚拟内核的个数
  4. yarn.scheduler.maximum-allocation-vcores 32 container最大的虚拟内核的个数
  5. yarn.nodemanager.resource.memory-mb 8192 每个nodemanager给多少内存 虚拟的

容错相关参数

  1. mapreduce.map.maxattempts: 每个Map Task最大重试次数，一旦重试参数超过该值，则认为Map Task运行失败，默认值：4。
  2. mapreduce.reduce.maxattempts: 每个Reduce Task最大重试次数，一旦重试参数超过该值，则认为Map Task运行失败，默认值：4。
  3. mapreduce.job.maxtaskfailures.per.tracker: 当失败的Map Task失败比例超过该值为，整个作业则失败，默认值为0. 如果你的应用程序允许丢弃部分输入数据，则该该值设为一个大于0的值，比如5，表示如果有低于5%的Map Task失败（如果一个Map Task重试次数超过mapreduce.map.maxattempts，则认为这个Map Task失败，其对应的输入数据将不会产生任何结果），整个作业仍认为成功。
  4. mapreduce.task.timeout: Task超时时间，默认值为600000毫秒，经常需要设置的一个参数，该参数表达的意思为：如果一个task在一定时间内没有任何进入，即不会读取新的数据，也没有输出数据，则认为该task处于block状态，可能是卡住了，也许永远会卡主，为了防止因为用户程序永远block住不退出，则强制设置了一个该超时时间（单位毫秒）。如果你的程序对每条输入数据的处理时间过长（比如会访问数据库，通过网络拉取数据等），建议将该参数调大，该参数过小常出现的错误提示是“AttemptID:attempt_14267829456721_123456_m_000224_0 Timed out after 300 secsContainer killed by the ApplicationMaster.”。

本地运行mapreduce 作业

设置以下几个参数:
file:///
mapreduce.framework.name=local
mapreduce.jobtracker.address=local
fs.defaultFS=local

效率和稳定性相关参数

  1. mapreduce.map.speculative: 是否为Map Task打开推测执行机制，默认为true，如果为true，如果Map执行时间比较长，那么集群就会推测这个Map已经卡住了，会重新启动同样的Map进行并行的执行，哪个先执行完了，就采取哪个的结果来作为最终结果，一般直接关闭推测执行
  2. mapreduce.reduce.speculative: 跟map类型。一般直接关闭推测执行
  3. mapreduce.input.fileinputformat.split.minsize: FileInputFormat做切片时的最小切片大小，默认为0
    (切片的默认大小就等于blocksize，即 134217728)

如果一个任务长时间不能完成执行，很有可能是发生了数据倾斜。
数据倾斜：大量数据都涌到一个reduce task里面，造成其中一个reduce task迟迟不能完成执行，例如，reduce task 走到80%的完成度就走不动了。

yarn资源调度

yarn是我们hadoop2.x当中引进的一个新的模块，主要用于管理我们集群当中的资源
比如说：内存，cpu
yarn还管理运行的一些任务信息等。

yarn调度的两个层级
一级管理调度：
管理计算机的资源
运行的job任务的生命周
二级管理调度：
任务的计算模型
多样化的计算模型 storm spark

yarn集群的监控管理界面：
http://node01:8088/cluster
jobHistoryServer查看界面：
http://node01:19888/jobhistory

yarn主要组件和作用

  • resourceManager：主节点，主要用于接收用户的请求，分配资源
  • nodeManager：从节点，主要用于处理任务的计算
  • ApplicationMaster：每提交一个任务，启动一个appmaster

ApplicationMaster主要职责：

  1. 申请资源
  2. 分配资源（分配container）
  3. 监控任务执行的进度状况
  4. 回收资源
  5. 与resourceManager通信，报告任务的执行状况
  6. 自杀
  • Container:资源分配的单位，所有的资源都是以container的形式来进行划分的，便于资源的分配和回收
  • jobHistory：历史完成的任务的日志信息
  • TimeLineServer: 2.4版本以后出来的新特性，查看正在执行的任务的信息

yarn当中的调度器

调度器主要解决的是任务先后提交，如何保证任务最快执行的一种策略，研究的是任务之间如何一起执行的问题。

hadoop当中的调度器主要有三种

  1. fifo 队列调度器，first in first out 没人用
    第一个任务来了，先执行，第二个任务来了，等着
    如果一个很大的计算任务先来，需要执行两个小时，再来一个小任务，需要执行两分钟

  2. capacity scheduler 容量调度器 apache的hadoop版本默认使用的
    将我们集群的资源，划分成好几个队列
    30% 40% 30%
    3 4 3
    任务提交的时候，可以选择不同的队列来进行提交
    根据提交的任务需要的资源大小不同，可以将我们的任务，划分到不同的队列下面去

  3. fairScheduler 公平调度器 CDH版本的hadoop默认的调度规则
    如果没有任务提交，第一个任务过来，将集群当中的所有的资源全部给第一个任务
    第二个任务来了，将第一个任务的资源划分一点出来给第二个任务，保证第二个任务也可以窒息感
    保证每一个任务都可以公平的一起执行

一般调度器不会去更改

使用哪种调度器取决于yarn-site.xml当中的
yarn.resourcemanager.scheduler.class 这个属性的配置

yarn常用参数设置

container分配最小内存
yarn.scheduler.minimum-allocation-mb 1024 给应用程序container分配的最小内存

container分配最大内存
yarn.scheduler.maximum-allocation-mb 8192 给应用程序container分配的最大内存

每个container的最小虚拟内核个数
yarn.scheduler.minimum-allocation-vcores 1 每个container默认给分配的最小的虚拟内核个数

每个container的最大虚拟内核个数
yarn.scheduler.maximum-allocation-vcores 32 每个container可以分配的最大的虚拟内核的个数

nodeManager可以分配的内存大小
yarn.nodemanager.resource.memory-mb 8192 nodemanager可以分配的最大内存大小，默认8192Mb

在**yarn-site.xml**中修改来改变默认值:

**定义每台机器的内存使用大小**
yarn.nodemanager.resource.memory-mb	8192

**定义每台机器的虚拟内核使用大小**
yarn.nodemanager.resource.cpu-vcores	8

**定义交换区空间可以使用的大小**（交换区空间就是讲一块硬盘拿出来做内存使用）
这里指定的是nodemanager的n内存的2.1倍
yarn.nodemanager.vmem-pmem-ratio	2.1
菜小雨
关注
Hadoop大数据入门到实战（第七节）- Mapreduce的使用
vip2193的博客
08-21 2921
MapReduce是Hadoop的核心功能之一，我们首先需要弄明白MapReduce到底是个啥，是干啥子用滴才行。 什么是MapReduce MapReduce是一种可用于数据处理的编程模型，我们现在设想一个场景，你接到一个任务，任务是：挖掘分析我国气象中心近年来的数据日志，该数据日志大小有3T,让你分析计算出每一年的最高气温，如果你现在只有一台计算机，如何处理呢？我想你应该会读取这些数据...
Hadoop-12
Denovo的博客
03-01 140
过滤日志及自定义日志输出路径（自定义OutputFormat） 1）需求 过滤输入的log日志中是否包含atguigu （1）包含atguigu的网站输出到e:/atguigu.log （2）不包含atguigu的网站输出到e:/other.log 2）输入数据 log.txt: http://www.baidu.com http://www.google.com http://cn.bing.c...
Hadoop12-Hive
sheldonwong的专栏
09-14 128
1. 简介与核心概念 2. 架构 3. 使用 4. UDF 把phoneNumber转换成地区的UDF import java.util.HashMap; import org.apache.hadoop.hive.ql.exec.UDF; public class PhoneNbrToArea extends UDF{ private static HashMap&lt;S...
头哥实践平台之MapReduce基础实战
m0_74459049的博客
11-12 7068
头哥实践平台之MapReduce基础实战
实验七：掌握基本的MapReduce编程方法 (JAVA+Python实现)(编程实现文件合并和去重操作,编写程序实现对输入文件的排序,对给定的表格进行信息挖掘)
Weary_PJ的博客
04-22 1万+
一、实验目的： 1. 理解MapReduce的工作机制； 2. 掌握基本的MapReduce编程方法 3. 重点理解map过程，shuffle过程和reduce过程 二、实验环境： Hadoop+Eclipse+JDK 三、实验内容和要求： 1.编程实现文件合并和去重操作 对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文...
mapred.zip_hadoop_hadoop mapreduce_mapReduce
09-20
在Hadoop生态系统中，MapReduce是一种分布式计算框架，它允许用户编写并运行处理大量数据的程序。这个"mapred.zip"文件显然包含了与Hadoop MapReduce相关的测试样例、文档和源码，这对于理解MapReduce的工作原理以及...
MR.rar_hadoop_mapReduce_paidabk
09-24
标题中的“MR.rar_hadoop_mapReduce_paidabk”暗示了这是一个与Hadoop MapReduce相关的压缩文件，其中可能包含了实现MapReduce算法的源代码以及与Hadoop框架相关的JAR包。这个压缩包很可能是为了帮助开发者理解和...
Mapreduce实现KNN算法和K-means算法.zip_bottleudc_hadoop_java_mapReduce_p
09-23
这两种算法在分类和聚类分析中具有重要应用，而通过Hadoop的MapReduce框架，可以有效地分布式处理大量数据。 首先，我们来看KNN算法。KNN是一种基于实例的学习方法，它的核心思想是：一个未知类别的数据点可以通过...
hadoop_join.jar.zip_hadoop_hadoop query_reduce
09-20
在大数据处理领域，Hadoop和MapReduce是两个至关重要的概念，它们构成了大数据处理的基础框架。本文将深入探讨如何使用Hadoop和MapReduce进行高效的Join查询，并解析如何通过`hadoop_join.jar`这个工具来实现这一...
pc机连接集群的HADOOP_HOME
12-14
Hadoop分布式文件系统（HDFS）和MapReduce是其核心组件，允许数据在集群中的多台服务器上进行分布式计算。标题“pc机连接集群的HADOOP_HOME”指的是在个人计算机（PC）上配置Hadoop环境，以便能够远程连接并操作一个...
大数据从入门到实战 - 第3章 MapReduce基础实战，cz教你MapReduce实战操作
05-26 6162
第1关：成绩统计： 为了完成本关任务，你需要掌握：1.什么是MapReduce，2.如何使用MapReduce进行运算。 什么是MapReduce MapReduce是一种可用于数据处理的编程模型，我们现在设想一个场景，你接到一个任务，任务是：挖掘分析我国气象中心近年来的数据日志，该数据日志大小有3T,让你分析计算出每一年的最高气温，如果你现在只有一台计算机，如何处理呢？我想你应该会读取这些数据，并且将读取到的数据与目前的最大气温值进行比较。比较完所有的数据之后就可以得出最高气温了。不过以我们的经验都
MapReduce基础实战
最新发布
2301_77225918的博客
11-13 1254
使用MapReduce计算班级每个学生的最好成绩，输入文件路径为/user/test/input，请将计算后的结果输出到/user/test/output/目录下。对于两个输入文件，即文件file1和文件file2，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件file3。输入文件在你每次点击评测的时候，平台会为你创建，无需你自己创建，只需要启动HDFS，编写java代码即可。输入文件路径为：/user/tmp/input/；
第7章 MapReduce实战
uzpoob的博客
06-17 6556
第1关：年龄统计 编程要求 使用MapReduce计算班级每个学生的最好成绩，输入文件路径为/user/test/input，请将计算后的结果输出到/user/test/output/目录下。 测试说明 输入文件在你每次点击评测的时候，平台会为你创建，无需你自己创建，只需要启动HDFS，编写java代码即可。 输入文件的数据格式如下： 张三 12 李四 13 张三 89 李四 92 ... 依照如上格式你应该输出： 李四 92 具体本关的预期输出请查看右侧测试集。 因为大数据实训消耗资源
hadoop入门7：自定义GroupingComparator进行分组
每天进步一点
10-06 1033
摘要： GroupingComparator是在reduce阶段分组来使用的，由于reduce阶段，如果key相同的一组，只取第一个key作为key，迭代所有的values。 如果reduce的key是自定义的bean，我们只需要bean里面的某个属性相同就认为这样的key是相同的，这是我们就需要之定义GroupCoparator来“欺骗”reduce了。 我们需要理清楚的还有map阶段你的几个...
实验4 MapReduce编程初级实践【java编程实现】
yyun05的博客
11-17 2531
1.编程实现文件合并和去重操作 对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。下面是输入文件和输出文件的一个样例供参考。 输入文件A的样例如下： 20150101 x 20150102 y 20150103 x 20150104 y 20150105 z 20150106 x 输入文件B的样例如下： ...
Java大数据培训学校全套教程-51）MapReduce进阶
08-03
java大数据培训学校全套教材系列课程由1000集视频构成，基本就 是1）时下流行的java培训学校主流内部教材，2）和市面上培训学校的通 行的课程体系几乎一样。所以这套课程都能自己学下来，等于上了培训学 校一次，完全可以找个java工程师的工作了。      通过学习MapReduce程序，如何输入文件是两个文件，Partitioner的用法，Combiner的用法，自定义对象，排序sort，topN问题，全局变量，剖析源码单步调试详解MapReduce分组group遍历，reduce当中的cleanup的用法，自定义输出：多文件输出MultipleOutputs，DBOutputFormat把MapReduce结果输出到mysql中，MapReduce实现join算法，map端做join，寻找用户间的共同好友等，围绕着Mapreduce知识点的相关14个问题，学过后可以基本胜任MapReduce编程工作。课程特色：专业细致，偏案例，理论强。课程软件使用：必须下载 2018 eclipse 4.7 oxygen版本重要声明： 如果感觉噪音大，可以选择不用耳机，加音箱或用电脑原声 
实验5 MapReduce初级编程实践（1）——编程实现文件合并和去重操作
热门推荐
程序必须为人类阅读而编写，并且仅仅碰巧可以让机器执行
11-22 3万+
一、实验目的 通过实验掌握基本的MapReduce编程方法； 掌握用MapReduce解决一些常见的数据处理问题，包括数据去重、数据排序和数据挖掘等。 二、实验平台 操作系统：Linux（建议Ubuntu16.04或Ubuntu18.04） Hadoop版本：3.1.3 三、实验内容 编程实现文件合并和去重操作 对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。下面是输入文件和输出文件的一个样例供参考。 输入文件A的样
Mapreduce单词词频统计实例
Melody_12的博客
06-01 644
开启hdfs 编写两个文件 上传到hdfs上 1）在根路径上新建文件夹 2）上传 3）上传成功 查看文件内容 运行程序 1）报错（原因：没有启动yarn，找不到资源管理器） 2）启动yarn 3）启动成功 查看输出数据 查看内容 ...
MapReduce编程(二) 文件合并和去重
我只是一个简单的Coder，为了兴趣和理想奋斗在生活的道路上
03-02 1万+
file1.txt中的内容:20150101 x 20150102 y 20150103 x 20150104 yfile2.txt中的内容:20150105 z 20150106 x 20150101 y 20150102 yfile3.txt中的内容:20150103 x 20150104 z 20150105 ...
please set $hadoop_mapred_home to the root of your hadoop mapreduce installa
06-01
To set the `hadoop_mapred_home` environment variable to the root of your Hadoop MapReduce installation, you can follow these steps: 1. Determine the location of your Hadoop MapReduce installation. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值