Hudi相关核心概念【时间线、索引...】

已于 2024-10-05 20:11:00 修改
阅读量591 收藏 16
点赞数 21
文章标签： scala 大数据
于 2024-10-05 20:09:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74453787/article/details/142715116
版权

文章目录

hudi核心概念

1.1时间线

  时间线，按照时间的发展，对每一个动作或事件和行为做一个记录
在这里插入图片描述
 时间线的作用时间线可以帮助用户了解表的历史变化，以及在特定时间点上表的状态。

  • 可以查询表在过去某个时间点上的数据。
  • 用于恢复数据。如果表的数据出现损坏或丢失，可以通过时间线找到最近的一个完整的时间点，然后从该时间点开始恢复数据。

时间线存储的内容，instants(某个事件所对应的时刻)

1.1.1 Action

记录了表的所有操作

  • commits：一次commit表示将一批数据原子性地写入一个表。

原子性：只有写入和不写入，不会出现部分数据写入而另一部分数据未写入的情况

    • cleans：清除表中不再需要的旧版本文件的后台活动。
    • delta_commit：增量提交指的是将一批数据原子性地写入一个MergeOnRead类型的表，其中部分或所有数据可以写入增量日志。
    • compaction：合并Hudi内部差异数据结构的后台活动，例如:将更新操作从基于行的log日志文件合并到列式存储的数据文件。在内部，COMPACTION体现为timeline上的特殊提交。
    • rollback：表示当commit/delta_commit不成功时进行回滚，其会删除在写入过程中产生的部分文件。
    • savepoint：将某些文件组标记为已保存，以便其不会被删除。在发生灾难需要恢复数据的情况下，它有助于将数据集还原到时间轴上的某个点。
1.1.2 Time

  操作时间，通常是一个时间戳（例如：20190117010349），它按照动作开始时间的顺序单调增加。

1.1.3 State
  • REQUESTED：表示某个action已经调度，但尚未执行。
  • INFLIGHT：表示action当前正在执行。
  • COMPLETED：表示timeline上的action已经完成。
两个重要的时间概念：
  • Arrival time: 数据到达 Hudi 的时间，commit time。
  • Event time: record 中记录的时间，原始数据所带的时间。
    Hudi 的时间线可以记录表的所有操作，主要用于处理迟到数据

2.1文件布局

在这里插入图片描述
Hudi存储分为两个部分：
 （1）元数据：.hoodie目录对应着表的元数据信息，包括表的版本管理（Timeline）、归档目录（存放过时的instant也就是版本），一个instant记录了一次提交（commit）的行为、时间戳和状态，Hudi以时间轴的形式维护了在数据集上执行的所有操作的元数据；
 （2）数据：和hive一样，以分区方式存放数据；分区里面存放着Base File（.parquet）和Log File（.log.*）；在每个分区中，文件被组织成文件组，由文件ID唯一标识；

3.1 索引

  • 索引原理
     Hudi通过索引机制提供高效的upserts，具体是将给定的hoodie key(record key + partition path)与文件id（文件组）建立唯一映射。这种映射关系，数据第一次写入文件后保持不变，所以，一个 FileGroup 包含了一批 record 的所有版本记录。Index 用于区分消息是 INSERT 还是 UPDATE。
  • 索引类型
    1.Bloom Filter Index（布隆过滤器索引）：
    • 原理：使用布隆过滤器数据结构来判断一个元素是否可能存在于一个集合中。对于 Hudi 表中的每个数据文件，构建一个布隆过滤器，记录文件中包含的记录键。
    • 优点：占用空间相对较小，查询速度快。能够快速判断一个记录键是否可能存在于某个数据文件中，减少不必要的文件读取。
    • 适用场景：适用于数据量大、查询频繁的场景，可以有效地减少磁盘 I/O 操作。
      2.HBase Index：
    • 原理：利用 HBase 作为外部存储来构建索引。将记录键和数据文件的位置信息存储在 HBase 中，通过查询 HBase 来确定记录所在的文件。
    • 优点：可以利用 HBase 的高可用性和可扩展性，提供强大的索引功能。对于大规模数据和高并发查询场景表现出色。
    • 适用场景：当需要处理大规模数据且对索引的性能和可靠性要求较高时，可以选择 HBase Index。

4.1 表类型

  1. Copy On Write 表
     当有新数据写入时，会直接覆盖原有数据文件。对于更新操作，会读取旧版本的数据文件，进行修改后写入新的文件。这种写入方式保证了数据的一致性，因为每次写入都是原子性的操作，要么全部成功，要么全部失败。
  2. Merge On Read 表
     写入操作会生成新的增量文件，而不是直接覆盖旧文件。在读取数据时，会合并基本文件和增量文件，得到最新的结果。
    这种方式可以提高写入的效率，因为不需要每次都进行全表的覆盖操作。
  3. COW与MOR的对比
Copy On WriteMerge On Read
高低数据延迟
低高查询延迟
高(重写整个Parquet文件)低(追加到增量日志)Update(I/O)更新成本
低(更新成本I/O高)较大(低更新成本)Parquet文件大小
大低写放大
批式处理流式处理使用场景

5.1 使用saprk读取hudi数据

5.2准备环境

创建Maven工程，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>com.atguigu.hudi</groupId>
    <artifactId>spark-hudi-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <scala.version>2.12.10</scala.version>
        <scala.binary.version>2.12</scala.binary.version>
        <spark.version>3.2.2</spark.version>
        <hadoop.version>3.1.3</hadoop.version>
        <hudi.version>0.12.0</hudi.version>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- 依赖Scala语言 -->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>
        <!-- Spark Core 依赖 -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- Spark SQL 依赖 -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- Hadoop Client 依赖 -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- hudi-spark3.2 -->
        <dependency>
            <groupId>org.apache.hudi</groupId>
            <artifactId>hudi-spark3.2-bundle_${scala.binary.version}</artifactId>
            <version>${hudi.version}</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <!-- assembly打包插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.0.0</version>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <archive>
                        <manifest>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
            </plugin>

            <!--Maven编译scala所需依赖-->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>
5.3 插入数据

import org.apache.hudi.QuickstartUtils._
import org.apache.spark.SparkConf
import org.apache.spark.sql._
import scala.collection.JavaConversions._
import org.apache.spark.sql.SaveMode._
import org.apache.hudi.DataSourceWriteOptions._
import org.apache.hudi.config.HoodieWriteConfig._


object InsertDemo {
  def main( args: Array[String] ): Unit = {
    // 创建 SparkSession
    val sparkConf = new SparkConf()
      .setAppName(this.getClass.getSimpleName)
      .setMaster("local[*]")
      .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    val sparkSession = SparkSession.builder()
      .config(sparkConf)
      .enableHiveSupport()
      .getOrCreate()

    val tableName = "hudi_trips_cow"
    val basePath = "hdfs://hadoop1:8020/tmp/hudi_trips_cow"
    val dataGen = new DataGenerator

    val inserts = convertToStringList(dataGen.generateInserts(10))
    val df = sparkSession.read.json(sparkSession.sparkContext.parallelize(inserts, 2))
    df.write.format("hudi").
      options(getQuickstartWriteConfigs).
      option(PRECOMBINE_FIELD.key(), "ts").
      option(RECORDKEY_FIELD.key(), "uuid").
      option(PARTITIONPATH_FIELD.key(), "partitionpath").
      option(TBL_NAME.key(), tableName).
      mode(Overwrite).
      save(basePath)
  }
}
5.4查询数据
import org.apache.spark.SparkConf
import org.apache.spark.sql._


object QueryDemo {
  def main( args: Array[String] ): Unit = {
    // 创建 SparkSession
    val sparkConf = new SparkConf()
      .setAppName(this.getClass.getSimpleName)
      .setMaster("local[*]")
      .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    val sparkSession = SparkSession.builder()
      .config(sparkConf)
      .enableHiveSupport()
      .getOrCreate()

    val basePath = "hdfs://hadoop1:8020/tmp/hudi_trips_cow"

    val tripsSnapshotDF = sparkSession.
      read.
      format("hudi").
      load(basePath)

    //    时间旅行查询写法一
    //    sparkSession.read.
    //      format("hudi").
    //      option("as.of.instant", "20210728141108100").
    //      load(basePath)
    //
    //    时间旅行查询写法二
    //    sparkSession.read.
    //      format("hudi").
    //      option("as.of.instant", "2021-07-28 14:11:08.200").
    //      load(basePath)
    //
    //    时间旅行查询写法三：等价于"as.of.instant = 2021-07-28 00:00:00"
    //    sparkSession.read.
    //      format("hudi").
    //      option("as.of.instant", "2021-07-28").
    //      load(basePath)

    tripsSnapshotDF.createOrReplaceTempView("hudi_trips_snapshot")

    sparkSession
      .sql("select fare, begin_lon, begin_lat, ts from  hudi_trips_snapshot where fare > 20.0")
      .show()

  }
}
5.5 增量查询
import org.apache.hudi.DataSourceReadOptions._
import org.apache.spark.SparkConf
import org.apache.spark.sql._


object IncrementalQueryDemo {
  def main( args: Array[String] ): Unit = {
    // 创建 SparkSession
    val sparkConf = new SparkConf()
      .setAppName(this.getClass.getSimpleName)
      .setMaster("local[*]")
      .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    val sparkSession = SparkSession.builder()
      .config(sparkConf)
      .enableHiveSupport()
      .getOrCreate()

    val basePath = "hdfs://hadoop1:8020/tmp/hudi_trips_cow"

    import sparkSession.implicits._
    val commits = sparkSession.sql("select distinct(_hoodie_commit_time) as commitTime from  hudi_trips_snapshot order by commitTime").map(k => k.getString(0)).take(50)
    val beginTime = commits(commits.length - 2)

    val tripsIncrementalDF = sparkSession.read.format("hudi").
      option(QUERY_TYPE.key(), QUERY_TYPE_INCREMENTAL_OPT_VAL).
      option(BEGIN_INSTANTTIME.key(), beginTime).
      load(basePath)

    tripsIncrementalDF.createOrReplaceTempView("hudi_trips_incremental")

    sparkSession.sql("select `_hoodie_commit_time`, fare, begin_lon, begin_lat, ts from  hudi_trips_incremental where fare > 20.0").show()

  }
}

6.1 使用spark将数据写入hudi

1）Copy On Write
（1）先对 records 按照 record key 去重（可选）
（2）不会创建 Index
（3）如果有小的 base file 文件，merge base file，生成新的 FileSlice + base file，否则直接写新的 FileSlice + base file
2）Merge On Read
（1）先对 records 按照 record key 去重（可选）
（2）不会创建 Index
（3）如果 log file 可索引，并且有小的 FileSlice，尝试追加或写最新的 log file；如果 log file 不可索引，写一个新的 FileSlice + base file

import org.apache.hudi.DataSourceWriteOptions._
import org.apache.hudi.QuickstartUtils._
import org.apache.hudi.config.HoodieWriteConfig._
import org.apache.spark.SparkConf
import org.apache.spark.sql.SaveMode._
import org.apache.spark.sql._

import scala.collection.JavaConversions._


object InsertOverwriteDemo {
  def main( args: Array[String] ): Unit = {
    // 创建 SparkSession
    val sparkConf = new SparkConf()
      .setAppName(this.getClass.getSimpleName)
      .setMaster("local[*]")
      .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    val sparkSession = SparkSession.builder()
      .config(sparkConf)
      .enableHiveSupport()
      .getOrCreate()

    val tableName = "hudi_trips_cow"
    val basePath = "hdfs://hadoop1:8020/tmp/hudi_trips_cow"
    val dataGen = new DataGenerator

    sparkSession.
      read.format("hudi").
      load(basePath).
      select("uuid","partitionpath").
      sort("partitionpath","uuid").
      show(100, false)


    val inserts = convertToStringList(dataGen.generateInserts(10))
    val df = sparkSession.read.json(sparkSession.sparkContext.parallelize(inserts, 2)).
      filter("partitionpath = 'americas/united_states/san_francisco'")

    df.write.format("hudi").
      options(getQuickstartWriteConfigs).
      option(OPERATION.key(),"insert_overwrite").
      option(PRECOMBINE_FIELD.key(), "ts").
      option(RECORDKEY_FIELD.key(), "uuid").
      option(PARTITIONPATH_FIELD.key(), "partitionpath").
      option(TBL_NAME.key(), tableName).
      mode(Append).
      save(basePath)

    sparkSession.
      read.format("hudi").
      load(basePath).
      select("uuid","partitionpath").
      sort("partitionpath","uuid").
      show(100, false)
  }
}
霸气的哦尼酱
关注
流式数据湖平台Hudi核心概念一：时间线
shangjg3的博客
10-10 180
顾名思义，为了在有效数据文件上提供元数据，并确保随着时间线的增长，对时间线的读取不会产生不必要的延迟，活动时间线需要以可以提供的元数据（时间线瞬间）为界。它提供了一套API和工具，可以帮助用户在数据湖中进行写入、更新、删除和查询等操作，并提供了高效的数据索引和存储机制，以加速数据的访问和处理。还提供了用于数据管理的元数据存储和查询功能，可以跟踪数据的版本、变更历史和元数据信息。一个关键的观察结果是，提交时间表示数据的到达时间是上午10:20，而实际的数据组织反映了数据的实际时间或事件时间。
【Hudi】数据湖Hudi核心概念与架构设计总结
热门推荐
菜鸟叔叔的博客
04-06 1万+
Hudi是现在非常热门的数据湖开源方案，非常适合于搭建一个数据湖平台。 有些人认为数据湖肯定与大数据技术体系完全不一样，是两个东西，甚至认为他俩没关系。但是，你知道Hudi的全称叫啥么？就是“Hadoop Updates and Incrementals” 简单来说，就是基于Hadoop生态，支持HDFS的数据删除和增量更新的技术框架。 所以，Apache Hudi其实本就是从Hadoop生态里来的，依赖 HDFS 做底层的存储，所以可以支撑非常大规模的数据存储。...
数据湖---hudi核心概念
u013257767的博客
12-30 1218
正如您所看到的，一个旧的查询不会看到当前飞行中提交的文件以粉色编码，而是在提交后开始的一个新的查询会拾取新的数据。因此，查询不受任何写入失败/部分写入的影响，仅在提交的数据上运行。如果您当前的部署模型是单编写器，以及在同一进程中运行的异步表服务（如清理、集群、压缩），如Deltastremer连续模式写入MOR表、Spark流（默认情况下压缩是异步的），以及您自己的作业设置在同一编写器中启用异步表服务，则必须具有乐观的并发控制，在启用元数据表之前配置的锁提供程序和延迟失败写入清理策略如下。
Hudi之TimeLine（时间轴）原理概念
wt334502157的博客
05-20 1080
​ 在Apache Hudi中，TimeLine是指，用于跟踪数据湖Hudi中数据的变化历史。TimeLine是Hudi的核心概念之一，用于管理和维护数据湖Hudi中各个数据集的变化历史。具体来说，TimeLine由一系列时间戳（timestamp）和相关的操作事件（如写入、更新、删除）组成，这些事件按时间顺序排列。每个数据集都有自己的TimeLine，用于记录该数据集的变化历史。​ 通过TimeLine，用户可以追溯数据集的变化历史，了解数据是如何随着时间变化的。
Hudi-核心概念(时间轴、文件管理、索引)
qq_38304392的博客
02-24 394
总述 hudi提供了hudi表的概念，这些表支持CRUD操作，可以利用现有的大数据集群比如HDFS做数据文件存储，然后使用SparkSQL或Hive等分析引擎进行数据分析查询 hudi表的三个主要组件 a.有序的时间轴元数据，类似于数据库事务日志 b.分层布局的数据文件：实际写入表中的数据 c.索引(多种实现方式)：映射包含指定记录的数据集；数据有唯一主键，可快速定位数据 1.时间轴Time...
探索 Apache Hudi 核心概念 (2) - File Sizing ( 控制文件大小 )
Laurence的技术博客
04-04 1078
本文首发于Apache Hudi公众号。在本系列的上一篇文章中，我们通过Notebook探索了COW表和MOR表的文件布局，在数据的持续写入与更新过程中，Hudi严格控制着文件的大小，以确保它们始终处于合理的区间范围内，从而避免大量小文件的出现，Hudi的这部分机制就称作“File Sizing”。本文，我们就针对COW表和MOR表的File Sizing进行一次深度探索。
数据湖架构Hudi（三）Hudi核心概念
qq_44665283的博客
03-01 2665
数据湖架构Hudi（三）Hudi核心概念
【Hudi】Hudi 核心知识点详解（一）
书山有路，学海无涯。记录成长，追逐梦想
12-10 3248
在 Flink 实时流中，经常会通过 Flink CDC 插件读取 Mysql 数据，然后写入 Hudi 中。所以在执行上述操作时，需要了解 Hudi 的基本概念以及操作原理，这样在近实时往 Hudi 中写数据时，遇到报错问题，才能及时处理。
Hudi学习笔记（三） 核心概念剖析
番茄炒蛋三分糖
06-12 993
Hudi 提供了Hudi 表的概念，这些表支持CRUD操作，可以利用现有的大数据集群比如HDFS做数据文件存储，然后使 用SparkSQL或Hive等分析引擎进行数据分析查询。 Hudi表的三个主要组件：1）有序的时间轴元数据，类似于数据库事务日志；2）分层布局的数据文件：实际写 入表中的数据；3）索引（多种实现方式）：映射包含指定记录的数据集。Hudi 核心：在所有的表中维护了一个包含在不同的即时（Instant）时间对数据集操作（比如新增、修改或删除） 的时间轴（Timeline）。在每一次对Hudi
数据湖Hudi.doc
10-14
Hudi的核心是其时间线机制，用于记录在不同时间点对表执行的所有操作，提供即时视图并支持按时间顺序检索数据。时间线由三部分组成： - **Instant action**：包括如commit、clean、delta_commit、compaction、...
「Apache Hudi系列」核心概念与架构设计总结
微信搜：import_bigdata，大数据领域硬核原创作者
02-08 1536
点击上方蓝色字体，选择“设为星标”回复”面试“获取更多惊喜简介Apache Hudi依赖 HDFS 做底层的存储，所以可以支撑非常大规模的数据存储。同时基于下面两个原语，Hudi可以解决流...
在Java项目中如何使用Scala实现尾递归优化来解决爆栈问题
2302_79840586的博客
10-02 811
Scala 作为一种多范式的编程语言，结合了面向对象和函数式编程的特性。在 Scala 中，尾递归 是通过编译器优化来防止栈溢出问题的。尾递归优化是一种特殊的优化方式，可以让递归调用不使用新的栈帧，从而避免递归调用过深时发生的栈溢出问题（StackOverflowError）。
Scala 字符串
wjs2024的博客
09-29 526
Scala 是一种多范式的编程语言，它结合了面向对象和函数式编程的特点。在 Scala 中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能更改它。Scala 字符串由 Java 字符串支持，因此 Scala 字符串的方法与 Java 字符串的方法非常相似。
大数据分析入门概述
m0_47498690的博客
10-04 1919
本文旨在为有意向学习数据分析、数据开发等大数据方向的初学者提供一个学习指南，当然如果你希望通过视频课程的方式快速入门，B站UP主戴戴戴师兄的课程质量很高，并且适合初学者快速入门。本文的目的旨在为想要了解大数据但不知道该学习什么内容的初学者介绍大数据相关的各类工具以及各项技能。后续会按照本文提到的关键字逐条更新更详细的内容以及具体案例。SQL（Structured Query Language）是一种标准化的编程语言，用于管理关系数据库管理系统（RDBMS），如MySQL、PostgreSQL、Oracle、
Hadoop之WordCount测试
最新发布
月亮的技术博客
10-04 536
Hadoop是Apache旗下的一个用Java语言实现的开源软件框架，是一个开发和运行处理大规模数据的软件平台。Hadoop的核心组件包括Hadoop分布式文件系统（HDFS）和MapReduce编程模型。HDFS是一个高度容错的系统，用于存储大规模数据集，具有高可靠性、高扩展性和高吞吐率的特点。MapReduce则是一个用于处理这些数据集的编程模型，它简化了并行编程的复杂性，使得开发者可以专注于业务逻辑的实现。Hadoop的优势在于其高可靠性、高扩展性、高效性、高容错性以及低成本。
netty之SpringBoot+Netty+Elasticsearch收集日志信息数据存储
CSDN_LiMingfly的博客
10-04 430
将大量的业务以及用户行为数据存储起来用于分析处理，但是由于数据量较大且需要具备可分析功能所以将数据存储到文件系统更为合理。尤其是一些互联网高并发级应用，往往数据库都采用分库分表设计，那么将这些分散的数据通过binlog汇总到一个统一的文件系统就显得非常有必要。#开发环境环境准备windows安装包 下载注意 es是以来java环境 所以需要安装jdk 支持1.7以上es-hander下载可视化操作插件@Id//姓名//年龄//级别//时间//电话//邮箱//地址。
项目管理-信息技术发展
GAVIN
10-04 328
对称加密：DES 3DES AES RC5 IEDA SM1 SM4。2）分类：PAN LAN MAN WAN 公用网 专用网。4）数据结构模型 层次模型 网状模型 关系模型。1)存储 分类：DAS FAS NAS SAN。物联网（IoT） 感知层 网络层 应用层。8） 5G 高速率 低时延 大连接。设备安全 数据安全 内容安全 行为安全。4.信息安全 保密性 完整性 可用性。3）网络协议 语法 语义 时许。5）IEEE 802 规范。6）TCP/IP 协议。4）网络标准协议 7层。
Kafka快速实战与基本原理详解
xajh_czbk的博客
09-29 602
消费消息：但是迟迟没有消费（因为kafka默认是从消费者启动之后开始消费，也就是说刚才发的那条消费不到，原因是那个时候消费者还没有启动。）我们现在启动了消费者了，可以尝试发消息了。另一种消费方式：指定从哪里消费。刚才第一次消费的时候没有消费test1，原因上面有写。这里的这个命令就可以消费到全部了,因为指定了从哪里消费。说白了，队列里的消息只能被同一个消费者组里面的一个消费者消费。关键他还可以重复消费。启动好了kafka之后，我们再去看ZK中的节点多了这些。创建一个主题并看一下：有了主题后就可以发消息了。
import org.apache.hudi.DataSourceWriteOptions._ import org.apache.hudi.QuickstartUtils.getQuickstartWriteConfigs import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}
05-26
这段代码主要是导入了 Hudi 相关的类和方法，并创建了一个 SparkSession 对象。其中： - `org.apache.hudi.DataSourceWriteOptions._` 导入了所有 Hudi 写入数据时需要用到的选项； - `org.apache.hudi.QuickstartUtils.getQuickstartWriteConfigs` 是 Hudi 提供的一个快速启动工具类，用于获取 Hudi 写入时需要的配置信息； - `org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}` 导入了 Spark SQL 相关的类，包括 DataFrame、SaveMode 和 SparkSession。 完整代码可能是这样的： ```scala import org.apache.hudi.DataSourceWriteOptions._ import org.apache.hudi.QuickstartUtils.getQuickstartWriteConfigs import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession} object HudiDemo { def main(args: Array[String]): Unit = { val spark = SparkSession.builder() .appName("HudiDemo") .master("local[*]") .getOrCreate() val data: DataFrame = spark.read.format("csv") .option("header", "true") .load("/path/to/csv") val hudiOptions = getQuickstartWriteConfigs data.write .format("org.apache.hudi") .options(hudiOptions) .mode(SaveMode.Overwrite) .save(hudiOptions.get(INSERT_OPERATION_OPT_KEY).get) } } ``` 这段代码将读取一个 CSV 文件并写入 Hudi 表中。其中，`getQuickstartWriteConfigs` 方法会返回一些默认的 Hudi 写入配置信息，你可以根据实际需求修改这些配置。最后，使用 `DataFrame.write` 将数据写入 Hudi 表中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值