Spark通过bulkLoad对HBase快速导入

最新推荐文章于 2024-08-14 18:12:00 发布
最新推荐文章于 2024-08-14 18:12:00 发布
阅读量269 收藏
点赞数
文章标签： 大数据 java scala
原文链接：https://segmentfault.com/a/1190000009762041
版权

项目中有需求将Hive的表存储在HBase中。通过Spark访问Hive表，通过一定ETL过程生成HFile，并通知HBase进行bulk load。实测这是导数最快的手段。

环境：

CDH : 5.7.0

Hadoop : 2.6.0-cdh5.7.0

Spark : 1.6.0-cdh5.7.0

Hive : 1.1.0-cdh5.7.0

HBase : 1.2.0-cdh5.7.0

pom

Hadoop项目里面，最坑的就是依赖关系复杂，然后经常会发现一些冲突包。。。下面是呕心沥血整理出无冲突的POM。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>your.group.id</groupId>
    <artifactId>your.artifact.id</artifactId>
    <version>your.version</version>
    <packaging>jar</packaging>

    <properties>
        <slf4j.version>1.7.5</slf4j.version>
        <scala.version>2.10</scala.version>
        <mysql.version>5.1.38</mysql.version>
        <logback.version>1.0.13</logback.version>

        <!-- Hadoop eco base version -->
        <hadoop.version>2.6.0</hadoop.version>
        <hbase.version>1.2.0</hbase.version>
        <zookeeper.version>3.4.5</zookeeper.version>
        <spark.version>1.6.0</spark.version>
        <hive.version>1.1.0</hive.version>

        <!-- Hadoop eco cdh version -->
        <cdh.version>5.7.0</cdh.version>
        <hadoop-cdh.version>${hadoop.version}-cdh${cdh.version}</hadoop-cdh.version>
        <hbase-cdh.version>${hbase.version}-cdh${cdh.version}</hbase-cdh.version>
        <zookeeper-cdh.version>${zookeeper.version}-cdh${cdh.version}</zookeeper-cdh.version>
        <spark-cdh.version>${spark.version}-cdh${cdh.version}</spark-cdh.version>
        <hive-cdh.version>${hive.version}-cdh${cdh.version}</hive-cdh.version>

        <!-- Hadoop eco current version -->
        <hadoop.current.version>${hadoop-cdh.version}</hadoop.current.version>
        <hbase.current.version>${hbase-cdh.version}</hbase.current.version>
        <zookeeper.current.version>${zookeeper-cdh.version}</zookeeper.current.version>
        <spark.current.version>${spark-cdh.version}</spark.current.version>
        <hive.current.version>${hive-cdh.version}</hive.current.version>
    </properties>


    <dependencies>
        <!-- zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>${zookeeper.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.jboss.netty</groupId>
                    <artifactId>netty</artifactId>
                </exclusion>
            </exclusions>
            <!--<exclusions>-->
            <!--<exclusion>-->
            <!--<groupId>log4j</groupId>-->
            <!--<artifactId>log4j</artifactId>-->
            <!--</exclusion>-->
            <!--<exclusion>-->
            <!--<groupId>org.slf4j</groupId>-->
            <!--<artifactId>slf4j-log4j12</artifactId>-->
            <!--</exclusion>-->
            <!--</exclusions>-->
        </dependency>

        <!-- Hadoop & HBase -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>javax.servlet</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.eclipse.jetty.orbit</groupId>
                    <artifactId>javax.servlet</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>${hadoop.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>javax.servlet</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.eclipse.jetty.orbit</groupId>
                    <artifactId>javax.servlet</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>${hbase.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>${hbase.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>javax.servlet</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.eclipse.jetty.orbit</groupId>
                    <artifactId>javax.servlet</artifactId>
                </exclusion>
                <exclusion>
                    <artifactId>servlet-api-2.5</artifactId>
                    <groupId>org.mortbay.jetty</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- Spark -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>apache-log4j-extras</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-flume_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-mllib_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-graphx_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-yarn_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-assembly_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-launcher_${scala.version}</artifactId>
            <version>${spark.current.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- hive -->
        <!--<dependency>-->
            <!--<groupId>org.spark-project.hive</groupId>-->
            <!--<artifactId>hive-cli</artifactId>-->
            <!--<version>${hive.current.version}</version>-->
            <!--<exclusions>-->
                <!--<exclusion>-->
                    <!--<groupId>org.jboss.netty</groupId>-->
                    <!--<artifactId>netty</artifactId>-->
                <!--</exclusion>-->
            <!--</exclusions>-->
        <!--</dependency>-->

        <!-- log for java-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>log4j-over-slf4j</artifactId>
            <version>${slf4j.version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>${logback.version}</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>${logback.version}</version>
        </dependency>

        <!-- jdbc -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                    <showDeprecation>true</showDeprecation>
                    <showWarnings>true</showWarnings>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>aliyun-r</id>
            <name>aliyun maven repo remote</name>
            <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
        </repository>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
    </repositories>

</project>

要领

1.通过Spark访问Hive的表，导为DataFrame

这里要求你的Spark环境支持访问Hive。CDH已经帮你做好了

当然你不需要访问Hive则无视

2. 将DataFrame flatMap为 JavaRDD<ImmutableBytesWritable, KeyValue>

ImmutableBytesWritable其实是行键的包装类，KeyValue则是HBase里的一个单元格（Cell）

所以应该是有多个RDD记录共同构建成逻辑上HBase的一行

重点！！！！

生成HFile要求Key有序。开始是以为只要行键有序，即map之后，sortByKey就ok，后来HFileOutputFormat一直报后值比前值小（即未排序）。翻了很多鬼佬网站，才发现，这里的行键有序，是要求rowKey+列族+列名整体有序！！！
也就是说，你要管好列族+列名的排序。。。
（这就是折磨我一整个通宵的天坑啊啊啊啊。。。。）

demo: 现在一个表有两个列族 a 有列 a1 a2 ， b 有列 b1 b2
flatMap的时候，行键可以不管，输出的时候必须保证：

rowKey a a1 值
rowKey a a2 值
rowKey b b1 值
rowKey b b2 值

如果

rowKey a a2 值
rowKey a a1 值
rowKey b b2 值
rowKey b b1 值

则GG思密达（巨坑！）

行键再通过rdd.sortByKey() 以实现整体有序

3. HBase API对HBase进行操作，要以hbase用户身份进行。

这点可以通过

    System.setProperty("user.name","hbase");
    System.setProperty("HADOOP_USER_NAME", "hbase");

来实现，也可以以hbase用户身份进行spark-submit。我调试是在windows下直接idea debug，所以就酱。

4. 把Hadoop/Hive/HBase的相关配置xml添加到resources目录

这样可以避免各种显式的在代码里进行配置

代码

根据自己需要进行修改

public static void main(String args[]) throws Exception {
        String ip = "your.ip";

        String hdfsOutputDir = "/tmp/bulkload/" + System.currentTimeMillis(); // saveAsNewAPIHadoopFile 要求HDFS目录是不存在的，它自己创建

        System.setProperty("user.name","hbase");
        System.setProperty("HADOOP_USER_NAME", "hbase");
        System.setProperty("SPARK_LOCAL_HOSTNAME", ip);

        Class<?> classess[] = {
                ImmutableBytesWritable.class,
                KeyValue.class,
                Put.class,
                ImmutableBytesWritable.Comparator.class
        };

        SparkConf sparkConf = new SparkCont().setAppName("")
                .set("spark.sql.hive.metastore.jars", "builtin")
                .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
                .set("spark.kryo.referenceTracking", "false")
                .registerKryoClasses(classess); // 必须要用Kryo来序列化这些没实现序列化接口的类，否则你懂的

        JavaSparkContext ctx = new JavaSparkContext(sparkConf);

        HiveContext hctx = new HiveContext(ctx);
        hctx.sql("use YOUR_HIVE_DATABASE");

        String tableName = "YOUR_HIVE_TABLE";

        DataFrame table = hctx.table(tableName);

            JavaPairRDD<ImmutableBytesWritable, KeyValue> hbaseData = table.limit(1000).javaRDD().flatMapToPair(new PairFlatMapFunction<Row, ImmutableBytesWritable, KeyValue>() {
            private static final long serialVersionUID = 3750223032740257913L;

            @Override
            public Iterable<Tuple2<ImmutableBytesWritable, KeyValue>> call(Row row) throws Exception {
                List<Tuple2<ImmutableBytesWritable, KeyValue>> kvs = new ArrayList<>();
                
                for(xxxx) { // 你的逻辑
                    
                    // 在这里控制 列族+列名的排序
                    kvs.add(new Tuple2<>(rk, new KeyValue(rkBytes, "a".getBytes(), "a1".getBytes(),value)));
                    kvs.add(new Tuple2<>(rk, new KeyValue(rkBytes, "a".getBytes(), "a2".getBytes(),value)));
                    kvs.add(new Tuple2<>(rk, new KeyValue(rkBytes, "b".getBytes(), "b1".getBytes(),value)));
                    kvs.add(new Tuple2<>(rk, new KeyValue(rkBytes, "b".getBytes(), "b2".getBytes(),value)));
                }

                return kvs;
            }
        }).sortByKey(); // 这里让Spark去控制行键的排序


        Configuration conf = HBaseConfiguration.create();
        conf.set(TableOutputFormat.OUTPUT_TABLE,"your.hbase.table");
        Job job = Job.getInstance();
        job.setMapOutputKeyClass(ImmutableBytesWritable.class);
        job.setMapOutputValueClass(KeyValue.class);

        Connection conn = ConnectionFactory.createConnection(conf);
        TableName hbTableName = TableName.valueOf("your.hbase.namespace".getBytes(), "your.hbase.table".getBytes());
        HRegionLocator regionLocator = new  HRegionLocator(hbTableName, (ClusterConnection) conn);
        Table realTable = conn.getTable(hbTableName);

        HFileOutputFormat2.configureIncrementalLoad(job,realTable,regionLocator);

        hbaseData.saveAsNewAPIHadoopFile(hdfsOutputDir,ImmutableBytesWritable.class,KeyValue.class,HFileOutputFormat2.class,job.getConfiguration());
        
        // bulk load start
        LoadIncrementalHFiles loader = new LoadIncrementalHFiles(conf);
        Admin admin = conn.getAdmin();
        loader.doBulkLoad(new Path(hdfsOutputDir),admin,realTable,regionLocator);

        ctx.stop();
   }

have fun

weixin_34258838
关注
spark通过 BulkLoad 方式 海量数据 写入hbase
yy的博客
01-15 504
spark hbase bulkLoad
【Spark 实战系列】Spark 使用 BulkLoad 同步数据到 hbase 排序优化
JasonLee实时计算
11-20 1403
最近群里有同学问我 spark 用 bulk 写入 hbase 的时候报错，因为 rowkey 排序的问题，今天带大家分析一下这个问题，先看下面的 demo。
spark-hbase-BulkLoad
最新发布
celltobig的专栏
08-14 613
方法2: BulkLoad 的方式导入，spark 读取 hive 表，写入hbase 需要的 HFile 类型的 文件，写在 hdfs 上面，再使用BulkLoad ，把数据加载移动到hbase表中。缺点: 数据量较大会建成hbase regionserver 压力大，可能会导致regionserver not online ，宕机，造成服务不可用的状态，数据量小没事。方法1：先建 hbase表，再建hbase的外表hive表，做好字段映射，起一个MR 任务写入 hive外表，
Spark跨集群bulk load（6-2）
06-04
Spark跨集群bulk load（6-2）
使用Spark通过Bulkload的方式导数据到Hbase
qq1010234991的博客
08-10 1137
文章目录 Spark通过Bulk Load 写入Hbase 背景 BulkLoad Bulk Load的实现原理 使用Put普通的方式 java put方式 使用 Bulk Load方式导入数据 数据准备 maven依赖 完整代码 Hbase中结果 总结 其他 Spark通过Bul...
Spark生成HBase 的 HFile 文件,并使用BulkLoad 方式将 HFile 文件加载到对应的表中
TMH_ITBOY的博客
07-22 2258
先看一个问题 java.io.IOException: Added a key not lexically larger than previous. Current cell = M00000006/info:age/1563723718005/Put/vlen=4/seqid=0, lastCell = M00000006/info:name/1563723718005/Put/vlen=2/...
Spark使用Bulk Load将大量数据导入HBase以及遇到一些问题及解决方案
haibucuoba的博客
05-28 1613
1、涉及jar包依赖 <properties> <spark.version>2.3.2</spark.version> <java.version>1.8</java.version> <scala.version>2.11.8</scala.version> <scala.major.version>2.11</scala.major.
Spark BulkLoad批量读写Hbase
lyd882的博客
02-28 1614
Spark BulkLoad批量读写Hbase Spark读写Hbase，不要使用put逐条数据插入，效率太低了，要使用批量导入的方式！要分Hbase版本来做不同处理： Hbase 1.x版本 依赖： <!-- spark2.x依赖省略 ---> <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client&lt
Bulk Load——Spark 批量导入多列数据到HBase（scala/Java）
王某的博客
05-06 5575
一、流程 Spark加载HDFS上的数据 ——> 数据清洗 ——> 准备HBase表 ——> 数据量预估，预分裂——> 数据整理为表的格式 ——> 批量写入 ——> 优化 此文主要记录后四个步骤 未优化时，大概1200万条数据/h (10G数据) 二、准备HBase表 val table: HTable = null val tableName ...
通过Spark生成HFile，并以BulkLoad方式将数据导入到HBase
大数据学习与分享的博客
08-27 1531
在实际生产环境中，将计算和存储进行分离，是我们提高集群吞吐量、确保集群规模水平可扩展的主要方法之一，并且通过集群的扩容、性能的优化，确保在数据大幅增长时，存储不能称为系统的瓶颈。 具体到我们实际的项目需求中，有一个典型的场景，通常会将Hive中的部分数据，比如热数据，存入到HBase中，进行冷热分离处理。 我们采用Spark读取Hive表数据存入HBase中，这里主要有两种方式： 通过HBase的put API进行数据的批量写入 通过生成HFile文件，然后通过BulkLoad方式将数据存入HBas
java hdfs导入hbase_通过BulkLoad快速将海量数据导入到Hbase[Hadoop篇]
weixin_35903223的博客
02-26 413
在第一次建立Hbase表的时候，我们可能需要往里面一次性导入大量的初始化数据。我们很自然地想到将数据一条条插入到Hbase中，或者通过MR方式等。但是这些方式不是慢就是在导入的过程的占用Region资源导致效率低下，所以很不适合一次性导入大量数据。本文将针对这个问题介绍如何通过Hbase的BulkLoad方法来快速将海量数据导入到Hbase中。总的来说，使用 Bulk Load 方式由于利用了实现...
Spark读写HBase之使用Spark自带的API以及使用Bulk Load将大量数据导入HBase
自渡
12-16 427
1. 需要的jar包依赖 <properties> <spark.version>2.3.0</spark.version> <hbase.version>1.2.6</hbase.version> <scala.main.version>2.11</scala....
spark bulkload数据到hbase
liuwei063608的专栏
10-19 1211
spark bulkload数据到hbase 1. 查询数据放到dataframe 查询数据放到dataframe val imDate = sql(imSQL) 2. 放入指定格式的RDD并排序 放入指定格式的RDD并排序 val res = basicData.rdd .flatMap { row =&gt; { val kvs = ...
Spark写入HBase（BulkLoad方式）
窗外的屋檐
04-20 1440
在使用Spark时经常需要把数据落入HBase中，如果使用普通的Java API，写入会速度很慢。Spark提供了Bulk写入方式的接口。那么Bulk写入与普通写入相比有什么优势呢？ BulkLoad不会写WAL，也不会产生flush以及split。 如果我们大量调用PUT接口插入数据，可能会导致大量的GC操作。除了影响性能之外，严重时甚至可能会对HBase节点的稳定性造成影响。但是采用Bul...
Spark doBulkLoad数据进入hbase
qq_25954159的博客
10-18 3760
踩了很多坑，终于把数据做成HFile文件。 package com.hun.scala import java.text.SimpleDateFormat import java.util.Date import org.apache.commons.codec.digest.DigestUtils import org.apache.hadoop.fs.Path impor
spark批量写写数据到Hbase中（bulkload方式）
06-01 1137
1：为什么大批量数据集写入Hbase中，需要使用bulkload BulkLoad不会写WAL，也不会产生flush以及split。 如果我们大量调用PUT接口插入数据，可能会导致大量的GC操作。除了影响性能之外，严重时甚至可能会对HBase节点的稳定性造成影响。但是采用BulkLoad就不会有这个顾虑。 过程中没有大量的接口调用消耗性能 可以利用spark 强大的计算能力 ...
使用spark进行hbase的bulkload
抛物线的博客
07-22 1077
Datax从 其他数据源迁移数据到 HBase 实际上是走的 HBase 原生 api 接口，在少量数据的情况下没有问题，但当我们需要从 Hive 里，或者其他异构存储里批量导入几亿，几十亿的数据，那么用 DataX 这里就显得不那么适合，因为走原生接口为了避免影响生产集群的稳定性一定要做好限流，那么海量数据的迁移就很很慢，同时数据的持续写入会因为 flush，compaction 等机制占用较多的系统资源。在过去的几年里，HBase 有了长足的发展，它在越来越多的公司里扮演者越来越重要的角色。
SparkStreaming Bulkload入Hyperbase--应用与原理
u014468095的博客
11-09 2132
SparkStreaming Bulkload入Hyperbase–应用与原理 一、环境准备 见《Spark3.1.2 on TDH622》 二、补充jar包 三、关键代码说明 接入kafka数据 JavaInputDStream<ConsumerRecord<String, String>> stream = KafkaUtils.createDirectStream( ssc,
Spark通过BulkLoad高效将Hive表迁移到HBase
本文主要关注如何通过Spark的BulkLoad功能实现Hive表到HBase的高效批量导入。Spark版本为1.6.0-cdh5.7.0，而所依赖的Hadoop、Hive和HBase版本分别为2.6.0-cdh5.7.0、1.1.0-cdh5.7.0和1.2.0-cdh5.7.0，这些都是Apache...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值