Hadoop+Spark+Hive

Hadoop+Spark+Hive

上个项目用到了大数据相关的技术,之前没用过,这次接触使用之后回头整理了一下相关知识点,读者想深入了解还是建议看官网。。。

Hadoop

简介
Hadoop 采用 MapReduce 分布式计算框架,根据 GFS 原理开发了 HDFS(分布式文件系统),并根据 BigTable 原理开发了 HBase 数据存储系统。
Hadoop 是一种分析和处理大数据的软件平台,是一个用 Java 语言实现的 Apache 的开源软件框架,在大量计算机组成的集群中实现了对海量数据的分布式计算。
Hadoop 是一个基础框架,允许用简单的编程模型在计算机集群上对大型数据集进行分布式处理。它的设计规模从单一服务器到数千台机器,每个服务器都能提供本地计算和存储功能,框架本身提供的是计算机集群高可用的服务,不依靠硬件来提供高可用性。
环境搭建
参考:https://zhuanlan.zhihu.com/p/33117305#
ps:上述仅理想状态,不包含所有问题情况,自行解决
使用
使用较为简单,不做过多赘述,常用命令如下:
hdfs dfs -ls path	:	查看目录
hdfs dfs -get hdfs_path local_path	:	拉取文件到本地
hdfs dfs -put local_path hdfs_path	:	上传文件到hdfs
hdfs dfs -cout path	:	查看目录文件数量
hdfs dfs -du -h	:	查看目录大小
原理

Hadoop是Apache软件基金会所开发的并行计算框架与分布式文件系统。最核心的模块包括Hadoop CommonHDFSMapReduce

  1. HDFS架构原理

    HDFS采用master/slave架构。一个HDFS集群包含一个单独的NameNode和多个DataNode。
    
    NameNode作为master服务,它负责管理文件系统的命名空间和客户端对文件的访问。NameNode会保存文件系统的具体信息,包括文件信息、文件被分割成具体block块的信息、以及每一个block块归属的DataNode的信息。对于整个集群来说,HDFS通过NameNode对用户提供了一个单一的命名空间。
    
    DataNode作为slave服务,在集群中可以存在多个。通常每一个DataNode都对应于一个物理节点。DataNode负责管理节点上它们拥有的存储,它将存储划分为多个block块,管理block块信息,同时周期性的将其所有的block块信息发送给NameNode。
    
    SecondaryNameNode的作用是合并fsimage和edits文件,当SecondaryNameNode被唤醒时,将会合并fsimage和edits文件。
    fsimage:用来存放hdfs目录树信息。
    edits:用来存储日志,namenode的增删改操作都会记录在edits文件中。
    
    下图为HDFS系统架构图,主要有四个角色,Client、NameNode、DataNode、SecondaryNameNode。
    

在这里插入图片描述

执行原理:
1.write
	client向namenode发出写入请求
	namenode根据文件大小和block块配置返回部分datanode信息
	client将文件分快,按照顺序写入对应的datanode中
2.read
	client向namenode发出读取请求
	namenode返回文件存储的block块和datanode信息
	client根据信息读取数据
3.数据备份
	hdfs按照block块的形式存储数据到各个datanode中,文件的所有block会被复制,相同的block会被存放到不同的datanode中。namenode会定期收集所有datanode的心跳数据包,心跳数据包表示datanode正常工作。

hdfs读取数据会优先读取最近的节点,如果要读取的数据跨节点,将会先读出最近的数据,依次向后读取。
  1. MapReduce

    关于MapReduce,我看懂了,但是总结的点太多,懒得写,这里介绍大概,想深入了解自行百度找资料吧

    mapreduce最早是Google提出的一个软件架构,用于大规模数据集群分布式运算,其核心思想就是把一个任务拆分为多个任务并行执行(map),都执行完之后把执行结果汇总起来(reduce)。
    
    hadoop的mapreduce:
    	一个mapreduce作业通常会把输入的数据集分为若干个独立的数据块,由map任务的形式并行处理这些数据块(就近计算原则),框架会对Map的输出先进行排序,然后把结果输入给Reduce任务。
    	
    下图为mapreduce的框架组成
    

    mapreduce

  (1)JobTracker(master)
  JobTracker负责调度构成一个作业的所有任务,这些任务分布在不同的TaskTracker上(由上图的JobTracker可以看到2 assign map 和 3 assign reduce)。你可以将其理解为公司的项目经理,项目经理接受项目需求,并划分具体的任务给下面的开发工程师。
  
  (2)TaskTracker(slave)
  TaskTracker负责执行由JobTracker指派的任务,这里我们就可以将其理解为开发工程师,完成项目经理安排的开发任务即可。
  1. hadoopcommon
Hadoop 体系最底层的一个模块,为 Hadoop 各子项目提供各种工具,如:配置文件和日志操作等。

saprk

简介
spark是个开源的数据 分析集群计算框架,最初由加州大学伯克利分校AMPLab,建立于HDFS之上。spark与hadoop一样,用于构建大规模,延迟低的数据分析应用。spark采用Scala语言实现,使用Scala作为应用框架。

spark采用基于内存的分布式数据集,优化了迭代式的工作负载以及交互式查询。

与hadoop不同的是,spark与Scala紧密集成,Scala象管理本地collective对象那样管理分布式数据集。spark支持分布式数据集上的迭代式任务,实际上可以在hadoop文件系统上与hadoop一起运行(通过YARN,MESOS等实现)。
环境搭建
参考:https://cloud.tencent.com/developer/article/1423508
ps:上述仅理想状态,不包含所有问题情况,自行解决
使用
spark-shell:是Spark自带的一个Scala交互式操作Shell(没用过)
spark-submit:用于提交你的程序到spark集群上运行,如:.jar .py类型的程序。(spark-submit有很多的配置,详情见官网:https://spark.apache.org/docs/latest/configuration.html)注意配置,很重要!!!
spark-sql:spark提供的交互式查询,通过sql执行spark程序。把SQL转译成查询spark的语法。
pyspark:scala提供了对python的支持,你可以在spark中编写python
原理

这里只对现有理解进行阐述。。。

参考文章:https://zhuanlan.zhihu.com/p/70424613

  1. spark和mapreduce的区别
	1. 基于内存,mapreduce的map以及reduce是基于磁盘的,而spark是在内存中进行拆分收集操作
	2. RDD,RDD只是一种逻辑上的数据结构,spark的一个重要理念:数据移动不如数据计算,所以当spark有运行调度的时候,会将计算任务分发到各个节点中单独计算,而不是把数据收集起来再计算;一个RDD中包含一组分区,分区是spark中的最小单位;RDD可以被转换为其他RDD;在spark中,对于数据的执行和操作是分开的,spark秉承着懒加载的理念,也就是当出现对数据的操作指令出现之前,数据都是保存在RDD中的。
	3.算子的设计:不同于mapreduce只支持map、reduce一种计算方式,spark还支持transformation和action算子,且spark还支持java、scala、python等多种语言编程
  1. spark基本概念
RDD:是弹性分布式数据集(Resilient Distributed Dataset)的简称,是分布式内存的一个抽象概念,RDD代表一个不可变、可分区、里面的元素可并行计算的集合,提供了一种高度受限的共享内存模型。

DAG:是Directed Acyclic Graph(有向无环图)的简称,反映RDD之间的依赖关系。

Driver Program:控制程序,负责为Application构建DAG图。

Cluster Manager:集群资源管理中心,负责分配计算资源。

Worker Node:工作节点,负责完成具体计算。

Executor:是运行在工作节点(Worker Node)上的一个进程,负责运行Task,并为应用程序存储数据。

Application:用户编写的Spark应用程序,一个Application包含多个Job。

Job:作业,一个Job包含多个RDD及作用于相应RDD上的各种操作。

Stage:阶段,是作业的基本调度单位,一个作业会分为多组任务,每组任务被称为“阶段”。

Task:任务,运行在Executor上的工作单元,是Executor中的一个线程。

总结:Application由多个Job组成,Job由多个Stage组成,Stage由多个Task组成。Stage是作业调度的基本单位。

img1.

  1. spark架构
Spark集群由Driver, Cluster Manager(Standalone,Yarn 或 Mesos),以及Worker Node组成。对于每个Spark应用程序,Worker Node上存在一个Executor进程,Executor进程中包括多个Task线程。

preview

  1. spark任务执行流程
1,Application首先被Driver构建DAG图并分解成Stage。

2,然后Driver向Cluster Manager申请资源。

3,Cluster Manager向某些Work Node发送征召信号。

4,被征召的Work Node启动Executor进程响应征召,并向Driver申请任务。

5,Driver分配Task给Work Node。

6,Executor以Stage为单位执行Task,期间Driver进行监控。

7,Driver收到Executor任务完成的信号后向Cluster Manager发送注销信号。

8,Cluster Manager向Work Node发送释放资源信号。

9,Work Node对应Executor停止运行。

img

hive

简介
hive是基于Hadoop构建的一套数据仓库分析系统,它将结构化的数据文件映射为一张数据库表,并提供完整的SQL查询功能;

Hive是建立在Hadoop基础上的数据仓库基础架构。它提供了一系列的工具,可以用来进行数据提取转化加载(ETL),这是一种可以存储、查询和分析存储在 Hadoop 中的大规模数据的机制。Hive 定义了简单的类 SQL 查询语言,称为 QL ,它允许熟悉 SQL 的用户查询数据。同时,这个语言也允许熟悉 MapReduce 开发者的开发自定义的 mapper 和 reducer 来处理内建的 mapper 和 reducer 无法完成的复杂的分析工作。

题外话

之前在网上看到一道面试题:spark和hive哪个查询更快?为什么?

看到这其实应该知道答案是什么了,没错,是spark更快。原因就是hive是基于hadoop的mapreduce来执行分布式数据处理任务,而spark有自己的一套分布式数据处理机制。至于二者的区别,上面spark原理部分有提到。
环境搭建
参考:https://zhuanlan.zhihu.com/p/65825211
ps:上述仅理想状态,不包含所有问题情况,自行解决
使用
hive的使用比较简单,这里就不做过多赘述,由于是结构化文件数据库,所以大部分操作都是通过sql完成的,这里只需要会sql就好了。
原理
Hive是SQL解析引擎,将SQL转换为Map/reducer job然后在Hadoop执行。Hive的表其实就是HDFS的目录,按表名把文件夹分开。如果是分区表,则分区值是子文件夹,可以直接在Map/Reduce Job里使用这些数据。Hive把HQL语句转换成MR任务后,采用批处理的方式对海量数据进行处理。

img

  1. Hive的系统结构
Hive架构的根基是HDFS和MapReducer。
Hive 的数据存储在 HDFS 中,大部分的查询由 MapReduce 完成(包含 * 的查询,比如 select * from table 不会生成 MapRedcue 任务)
hive有三种运行模式:内嵌模式、本地模式、远程模式.
  1. 元数据存储系统 : RDBMS MySQL
元数据,通俗的讲,就是存储在 Hive 中的数据的描述信息。

Hive 中的元数据通常包括:表的名字,表的列和分区及其属性,表的属性(内部表和 外部表),表的数据所在目录.
  1. Hive的数据组织
1、Hive 的存储结构包括数据库、表、视图、分区和表数据等。数据库,表,分区等等都对 应 HDFS 上的一个目录。表数据对应 HDFS 对应目录下的文件。

2、Hive 中所有的数据都存储在 HDFS 中,没有专门的数据存储格式,因为 Hive 是读模式 (Schema On Read),可支持 TextFile,SequenceFile,RCFile 或者自定义格式等

3、 只需要在创建表的时候告诉 Hive 数据中的列分隔符和行分隔符,Hive 就可以解析数据

Hive 的默认列分隔符:控制符 Ctrl + A,\x01 Hive 的

Hive 的默认行分隔符:换行符 \n

4、Hive 中包含以下数据模型:

database:在 HDFS 中表现为${hive.metastore.warehouse.dir}目录下一个文件夹

table:在 HDFS 中表现所属 database 目录下一个文件夹

external table:与 table 类似,不过其数据存放位置可以指定任意 HDFS 目录路径

partition:在 HDFS 中表现为 table 目录下的子目录

bucket:在 HDFS 中表现为同一个表目录或者分区目录下根据某个字段的值进行 hash 散 列之后的多个文件

view:与传统数据库类似,只读,基于基本表创建

5、Hive 的元数据存储在 RDBMS 中,除元数据外的其它所有数据都基于 HDFS 存储。默认情 况下,Hive 元数据保存在内嵌的 Derby 数据库中,只能允许一个会话连接,只适合简单的 测试。实际生产环境中不适用,为了支持多用户会话,则需要一个独立的元数据库,使用 MySQL 作为元数据库,Hive 内部对 MySQL 提供了很好的支持。

6、Hive 中的表分为内部表、外部表、分区表和 Bucket 表

内部表和外部表的区别:
  删除内部表,删除表元数据和数据
  删除外部表,删除元数据,不删除数据

内部表和外部表的使用选择:
  大多数情况,他们的区别不明显,如果数据的所有处理都在 Hive 中进行,那么倾向于 选择内部表,但是如果 Hive 和其他工具要针对相同的数据集进行处理,外部表更合适。
  使用外部表访问存储在 HDFS 上的初始数据,然后通过 Hive 转换数据并存到内部表中
  使用外部表的场景是针对一个数据集有多个不同的 Schema
  通过外部表和内部表的区别和使用选择的对比可以看出来,hive 其实仅仅只是对存储在 HDFS 上的数据提供了一种新的抽象。而不是管理存储在 HDFS 上的数据。所以不管创建内部 表还是外部表,都可以对 hive 表的数据存储目录中的数据进行增删操作。

分区表和分桶表的区别:
  Hive 数据表可以根据某些字段进行分区操作,细化数据管理,可以让部分查询更快。同 时表和分区也可以进一步被划分为 Buckets,分桶表的原理和 MapReduce 编程中的 HashPartitioner 的原理类似。
  分区和分桶都是细化数据管理,但是分区表是手动添加区分,由于 Hive 是读模式,所 以对添加进分区的数据不做模式校验,分桶表中的数据是按照某些分桶字段进行 hash 散列 形成的多个文件,所以数据的准确性也高很多.

经验总结:多看官网!!!

  • 1
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 很抱歉,我是一名语言模型AI,无法亲自进行实际操作。但是,我可以提供一些基于Docker容器快速搭建Hadoop+Spark+Hive+HBase集群的详细过程记录的参考资料,供您参考。 1. 准备工作 首先,需要安装Docker和Docker Compose。可以参考官方文档进行安装。 2. 下载镜像 可以从Docker Hub上下载HadoopSparkHive和HBase的镜像。可以使用以下命令: ``` docker pull bde2020/hadoop-base:2.0.0-hadoop3.2.1-java8 docker pull bde2020/hadoop-namenode:2.0.0-hadoop3.2.1-java8 docker pull bde2020/hadoop-datanode:2.0.0-hadoop3.2.1-java8 docker pull bde2020/hadoop-resourcemanager:2.0.0-hadoop3.2.1-java8 docker pull bde2020/hadoop-nodemanager:2.0.0-hadoop3.2.1-java8 docker pull bde2020/hadoop-historyserver:2.0.0-hadoop3.2.1-java8 docker pull bde2020/hive:2.3.7-postgresql-metastore docker pull bde2020/spark-base:2.4.5-hadoop2.7 docker pull bde2020/spark-master:2.4.5-hadoop2.7 docker pull bde2020/spark-worker:2.4.5-hadoop2.7 docker pull bde2020/hbase:2.2.4-hadoop3.2.1-java8 ``` 3. 编写docker-compose.yml文件 可以编写一个docker-compose.yml文件来定义HadoopSparkHive和HBase的容器。以下是一个示例: ``` version: '3' services: namenode: image: bde2020/hadoop-namenode:2.0.0-hadoop3.2.1-java8 container_name: namenode ports: - "9870:9870" volumes: - ./hadoop-data/namenode:/hadoop/dfs/name environment: - CLUSTER_NAME=hadoop-cluster datanode: image: bde2020/hadoop-datanode:2.0.0-hadoop3.2.1-java8 container_name: datanode volumes: - ./hadoop-data/datanode:/hadoop/dfs/data environment: - CLUSTER_NAME=hadoop-cluster - CORE_CONF_fs_defaultFS=hdfs://namenode:8020 resourcemanager: image: bde2020/hadoop-resourcemanager:2.0.0-hadoop3.2.1-java8 container_name: resourcemanager ports: - "8088:8088" environment: - CLUSTER_NAME=hadoop-cluster - CORE_CONF_fs_defaultFS=hdfs://namenode:8020 - YARN_CONF_yarn_resourcemanager_hostname=resourcemanager nodemanager: image: bde2020/hadoop-nodemanager:2.0.0-hadoop3.2.1-java8 container_name: nodemanager environment: - CLUSTER_NAME=hadoop-cluster - CORE_CONF_fs_defaultFS=hdfs://namenode:8020 - YARN_CONF_yarn_resourcemanager_hostname=resourcemanager historyserver: image: bde2020/hadoop-historyserver:2.0.0-hadoop3.2.1-java8 container_name: historyserver ports: - "8188:8188" environment: - CLUSTER_NAME=hadoop-cluster - CORE_CONF_fs_defaultFS=hdfs://namenode:8020 - YARN_CONF_yarn_resourcemanager_hostname=resourcemanager hive-metastore-postgresql: image: bde2020/hive:2.3.7-postgresql-metastore container_name: hive-metastore-postgresql ports: - "5432:5432" environment: - POSTGRES_PASSWORD=hivepassword - POSTGRES_USER=hiveuser - POSTGRES_DB=hivemetastore spark-master: image: bde2020/spark-master:2.4.5-hadoop2.7 container_name: spark-master ports: - "8080:8080" environment: - SPARK_CONF_spark_master_host=spark-master - SPARK_CONF_spark_eventLog_enabled=true - SPARK_CONF_spark_eventLog_dir=/tmp/spark-events - SPARK_CONF_spark_history_fs_logDirectory=hdfs://namenode:8020/spark-logs - SPARK_CONF_spark_history_ui_port=18080 spark-worker-1: image: bde2020/spark-worker:2.4.5-hadoop2.7 container_name: spark-worker-1 environment: - SPARK_CONF_spark_master_url=spark://spark-master:7077 - SPARK_CONF_spark_worker_cores=2 - SPARK_CONF_spark_worker_memory=2g spark-worker-2: image: bde2020/spark-worker:2.4.5-hadoop2.7 container_name: spark-worker-2 environment: - SPARK_CONF_spark_master_url=spark://spark-master:7077 - SPARK_CONF_spark_worker_cores=2 - SPARK_CONF_spark_worker_memory=2g hbase-master: image: bde2020/hbase:2.2.4-hadoop3.2.1-java8 container_name: hbase-master ports: - "16010:16010" environment: - HBASE_CONF_hbase_regionserver_hostname=hbase-master - HBASE_CONF_hbase_master_hostname=hbase-master hbase-regionserver: image: bde2020/hbase:2.2.4-hadoop3.2.1-java8 container_name: hbase-regionserver environment: - HBASE_CONF_hbase_regionserver_hostname=hbase-regionserver - HBASE_CONF_hbase_master_hostname=hbase-master ``` 4. 启动容器 可以使用以下命令启动容器: ``` docker-compose up -d ``` 5. 验证集群 可以使用以下命令验证集群: ``` docker exec -it namenode bash hdfs dfs -mkdir /test hdfs dfs -ls / exit ``` ``` docker exec -it spark-master bash spark-submit --class org.apache.spark.examples.SparkPi --master spark://spark-master:7077 /opt/spark/examples/jars/spark-examples_2.11-2.4.5.jar 10 exit ``` ``` docker exec -it hive-metastore-postgresql bash psql -h localhost -U hiveuser -d hivemetastore \dt \q exit ``` ``` docker exec -it hbase-master bash hbase shell create 'test', 'cf' list exit ``` 以上是一个基于Docker容器快速搭建Hadoop+Spark+Hive+HBase集群的详细过程记录。希望对您有所帮助。 ### 回答2: Docker是一种轻量级的虚拟化技术,可以在同一操作系统中运行多个独立的容器,各个容器之间相互隔离。通过Docker容器,快速搭建HadoopSparkHive和Hbase集群成为了可能。下面是基于Docker容器,快速搭建HadoopSparkHive和Hbase集群的详细过程记录: 1. 下载Docker技术栈 在运行Docker之前,我们需要先安装Docker和Docker Compose。我们可以从官方Docker网站下载Docker和Docker Compose: - Docker的下载链接:https://www.docker.com/get-started - Docker Compose的下载链接:https://docs.docker.com/compose/install/ 2. 创建docker-compose.yml文件 在运行Docker之前,我们需要创建一个docker-compose.yml文件,该文件定义了Docker容器的配置和组合。我们将以下容器定义在该文件中: - Hadoop NameNode - Hadoop DataNode - Hadoop ResourceManager - Hadoop NodeManager - Spark Master - Spark Worker - Hive Server - HBase Master 我们可以通过以下命令创建docker-compose.yml文件: ``` version: "2.2" services: namenode: container_name: namenode image: cloudera/quickstart:latest hostname: namenode ports: - "8020:8020" - "50070:50070" - "50075:50075" - "50010:50010" - "50020:50020" volumes: - ~/hadoop-data/namenode:/var/lib/hadoop-hdfs/cache/hdfs/dfs/name environment: SERVICE_PRECONDITION: HDFS_NAMENODE datanode: container_name: datanode image: cloudera/quickstart:latest hostname: datanode ports: - "50075:50075" - "50010:50010" - "50020:50020" volumes: - ~/hadoop-data/datanode:/var/lib/hadoop-hdfs/cache/hdfs/dfs/data environment: SERVICE_PRECONDITION: HDFS_DATANODE resourcemanager: container_name: resourcemanager image: cloudera/quickstart:latest hostname: resourcemanager ports: - "8088:8088" - "8030:8030" - "8031:8031" - "8032:8032" - "8033:8033" environment: SERVICE_PRECONDITION: YARN_RESOURCEMANAGER nodemanager: container_name: nodemanager image: cloudera/quickstart:latest hostname: nodemanager environment: SERVICE_PRECONDITION: YARN_NODEMANAGER sparkmaster: container_name: sparkmaster image: sequenceiq/spark:2.1.0 hostname: sparkmaster ports: - "8081:8081" command: bash -c "/usr/local/spark/sbin/start-master.sh && tail -f /dev/null" sparkworker: container_name: sparkworker image: sequenceiq/spark:2.1.0 hostname: sparkworker environment: SPARK_MASTER_HOST: sparkmaster command: bash -c "/usr/local/spark/sbin/start-worker.sh spark://sparkmaster:7077 && tail -f /dev/null" hiveserver: container_name: hiveserver image: bde2020/hive:2.3.4-postgresql-metastore hostname: hiveserver ports: - "10000:10000" environment: METASTORE_HOST: postgres META_PORT: 5432 MYSQL_DATABASE: hive MYSQL_USER: hive MYSQL_PASSWORD: hive POSTGRES_DB: hive POSTGRES_USER: hive POSTGRES_PASSWORD: hive hbasemaster: container_name: hbasemaster image: harisekhon/hbase hostname: hbasemaster ports: - "16010:16010" - "2181:2181" command: ["bin/start-hbase.sh"] ``` 3. 运行Docker容器 运行Docker容器的第一步是将docker-compose.yml文件放置在合适的路径下。在运行Docker容器之前,我们需要从Docker Hub拉取镜像,并运行以下命令: ``` $ docker-compose up -d ``` 该命令会运行所有定义在docker-compose.yml文件中的容器。 4. 配置集群 在运行Docker之后,我们需要进入相应的容器,例如进入namenode容器: ``` $ docker exec -it namenode bash ``` 我们可以使用以下命令检查HadoopSparkHive和HBase集群是否正确配置: - Hadoop集群检查: ``` $ hadoop fs -put /usr/lib/hadoop/README.txt / $ hadoop fs -ls / ``` - Spark集群检查: ``` $ spark-shell --master spark://sparkmaster:7077 ``` - Hive集群检查: ``` $ beeline -u jdbc:hive2://localhost:10000 ``` - HBase集群检查: ``` $ hbase shell ``` 5. 关闭Docker容器 在测试完成后,我们可以使用以下命令关闭所有Docker容器: ``` $ docker-compose down --volumes ``` 综上所述,Docker容器是快速搭建HadoopSparkHive和HBase集群的理想选择。通过docker-compose.yml文件,我们可以轻松配置和管理整个集群。使用这种方法,可以节省大量的时间和精力,并使整个搭建过程更加方便和高效。 ### 回答3: Docker容器是一种轻型的虚拟化技术,能够快速搭建大型分布式系统集群。可以使用Docker容器快速搭建HadoopSparkHive和HBase集群。下面是基于Docker容器搭建大数据集群的详细过程记录: 1.安装Docker和Docker-Compose 首先需要安装Docker和Docker-Compose。可以按照官方文档详细教程进行安装。 2.创建Docker文件 创建一个Dockerfile文件用于构建HadoopSparkHive和HBase的镜像。在该文件内添加以下内容: FROM ubuntu:16.04 RUN apt-get update # Install JDK, Python, and other dependencies RUN apt-get install -y openjdk-8-jdk python python-dev libffi-dev libssl-dev libxml2-dev libxslt-dev # Install Hadoop RUN wget http://www.eu.apache.org/dist/hadoop/common/hadoop-2.7.7/hadoop-2.7.7.tar.gz RUN tar -xzvf hadoop-2.7.7.tar.gz RUN mv hadoop-2.7.7 /opt/hadoop # Install Spark RUN wget http://www.eu.apache.org/dist/spark/spark-2.4.0/spark-2.4.0-bin-hadoop2.7.tgz RUN tar -zxvf spark-2.4.0-bin-hadoop2.7.tgz RUN mv spark-2.4.0-bin-hadoop2.7 /opt/spark # Install Hive RUN wget http://www.eu.apache.org/dist/hive/hive-2.3.4/apache-hive-2.3.4-bin.tar.gz RUN tar -zxvf apache-hive-2.3.4-bin.tar.gz RUN mv apache-hive-2.3.4-bin /opt/hive # Install HBase RUN wget http://www.eu.apache.org/dist/hbase/hbase-1.4.9/hbase-1.4.9-bin.tar.gz RUN tar -zxvf hbase-1.4.9-bin.tar.gz RUN mv hbase-1.4.9 /opt/hbase # Set Environment Variables ENV JAVA_HOME /usr/lib/jvm/java-8-openjdk-amd64 ENV HADOOP_HOME /opt/hadoop ENV SPARK_HOME /opt/spark ENV HIVE_HOME /opt/hive ENV HBASE_HOME /opt/hbase ENV PATH $PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$SPARK_HOME/bin:$HIVE_HOME/bin:$HBASE_HOME/bin # Format HDFS RUN $HADOOP_HOME/bin/hdfs namenode -format 3.创建Docker-Compose文件 创建一个docker-compose文件,里面有一个master节点和两个worker节点。在docker-compose文件中添加以下内容: version: "3" services: master: image: hadoop-spark-hive-hbase container_name: master hostname: master ports: - "22" - "8088:8088" - "8030:8030" - "8031:8031" - "8032:8032" - "9000:9000" - "10020:10020" - "19888:19888" - "50010:50010" - "50020:50020" - "50070:50070" - "50075:50075" volumes: - /data:/data command: - /usr/sbin/sshd - -D worker1: image: hadoop-spark-hive-hbase container_name: worker1 hostname: worker1 ports: - "22" - "50010" - "50020" - "50075" volumes: - /data:/data command: - /usr/sbin/sshd - -D worker2: image: hadoop-spark-hive-hbase container_name: worker2 hostname: worker2 ports: - "22" - "50010" - "50020" - "50075" volumes: - /data:/data command: - /usr/sbin/sshd - -D 4.构建镜像 运行以下命令来构建镜像: docker build -t hadoop-spark-hive-hbase . 5.启动容器 运行以下命令来启动容器: docker-compose up -d 6.测试集群 在浏览器中输入http://IP地址:8088,可以看到Hadoop和YARN的Web控制台。 在浏览器中输入http://IP地址:50070,可以看到HDFS的Web控制台。 在浏览器中输入http://IP地址:8888,可以看到Jupyter Notebook。 在Jupyter Notebook中,创建一个Python文件并运行以下代码来测试Spark集群: from pyspark import SparkContext sc = SparkContext() rdd1 = sc.parallelize(range(1000)) rdd2 = sc.parallelize(range(1000, 2000)) rdd3 = rdd1.union(rdd2) rdd3.take(10) 以上就是基于Docker容器快速搭建HadoopSparkHive和HBase集群的详细过程记录。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值