大数据Hadoop之——Kafka Streams原理介绍与简单应用示例

于 2022-06-19 07:30:00 发布
阅读量802 收藏 5
点赞数 1
分类专栏： kafka kafka streams 文章标签： kafka kafka streams
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35745940/article/details/125249674
版权

文章目录

一、Kafka Streams概述

官网文档：https://kafka.apache.org/32/documentation/streams/

1）Kafka Streams是什么

Kafka Streams是一套客户端类库，它建立在重要的流处理概念之上，它可以对存储在Kafka内的数据进行流式处理和分析，简称“流式计算”。

2）流式计算与批量计算区别

  • 流式计算：输入是持续的，一般先定义目标计算，然后数据到来之后将计算逻辑应用于数据，往往用增量计算代替全量计算。
  • 批量计算：一般先有全量数据集，然后定义计算逻辑，并将计算应用于全量数据。特点是全量计算，并且计算结果一次性全量输出。

3）Kafka Streams特点

  • 简单轻量级的客户端库，可以轻松嵌入任何 Java 应用程序，并与用户为其流应用程序拥有的任何现有打包、部署和操作工具集成。
  • 除了作为内部消息传递层的Apache Kafka本身之外，对系统没有外部依赖；值得注意的是，它使用 Kafka 的分区模型来水平扩展处理，同时保持强大的排序保证。
  • 支持容错本地状态，这可以实现非常快速和高效的有状态操作，例如窗口连接和聚合。
  • 支持一次性处理语义，以保证每条记录将被处理一次且仅处理一次，即使在处理过程中 Streams 客户端或 Kafka 代理出现故障时也是如此。
  • 采用一次一条记录的处理来实现毫秒处理延迟，并支持基于事件时间的窗口操作，记录无序到达。
  • 提供必要的流处理原语，以及高级 Streams DSL和低级处理器 API。

二、Kafka Streams流处理拓扑

在这里插入图片描述

1）相关概念

  • 流是 Kafka Streams 提供的最重要的抽象：它代表了一个无限的、不断更新的数据集。流是不可变数据记录的有序、可重放和容错序列，其中数据记录被定义为键值对。
  • 流处理应用程序是任何使用 Kafka Streams 库的程序。它通过一个或多个处理器拓扑定义其计算逻辑，其中处理器拓扑是由流（边）连接的流处理器（节点）的图。
  • 流处理器是处理器拓扑中的一个节点；它表示一个处理步骤，通过从拓扑中的上游处理器一次接收一个输入记录，将其操作应用到它，并可能随后产生一个或多个输出记录到其下游处理器，从而转换流中的数据。

拓扑中有两个特殊的处理器：

  • 源处理器：源处理器是一种特殊类型的流处理器，它没有任何上游处理器。它通过使用来自这些主题的记录并将它们转发到其下游处理器，从一个或多个 Kafka 主题生成其拓扑的输入流。
  • 接收器处理器：接收器处理器是一种特殊类型的流处理器，它没有下游处理器。它将任何从其上游处理器接收到的记录发送到指定的 Kafka 主题。

2）Kafka Streams中两种定义流处理的方法

  • Kafka Streams DSL map提供了最常见的数据转换操作；例如开箱即filter用join；
  • aggregations较低级别的处理器 API允许开发人员定义和连接自定义处理器以及与状态存储交互。

3）流处理中的三种时间

流处理的一个关键方面是时间的概念，以及它是如何建模和集成的。例如，一些操作，如加窗，是基于时间边界定义的。

  • 事件时间——事件或数据记录发生的时间点，即最初是“在源头”创建的。

示例：如果事件是由汽车中的 GPS 传感器报告的地理位置变化，则关联的事件时间将是 GPS 传感器捕获位置变化的时间。

  • 处理时间——事件或数据记录恰好被流处理应用程序处理的时间点，即记录被消费的时间。处理时间可能比原始事件时间晚几毫秒、几小时或几天等。

示例：想象一个分析应用程序，它读取并处理从汽车传感器报告的地理位置数据，以将其呈现给车队管理仪表板。在这里，分析应用程序中的处理时间可能是事件时间之后的毫秒或秒（例如，对于基于 Apache Kafka 和 Kafka Streams 的实时管道）或几小时（例如，对于基于 Apache Hadoop 或 Apache Spark 的批处理管道）。

  • 摄取时间——事件或数据记录由 Kafka 代理存储在主题分区中的时间点。与事件时间的区别在于，这个摄取时间戳是在 Kafka 代理将记录附加到目标主题时生成的，而不是在“在源”创建记录时生成的。处理时间的区别在于处理时间是流处理应用程序处理记录的时间。

例如，如果一条记录从未被处理过，它就没有处理时间的概念，但它仍然有一个摄取时间。

【温馨提示】事件时间 和 摄取时间 之间的选择实际上是通过 Kafka的配置来完成的（不是 Kafka Streams）：从 Kafka 0.10.x 开始，时间戳会自动嵌入到 Kafka 消息中。根据 Kafka 的配置，这些时间戳代表事件时间或摄取时间。

4）KTable和KSteam

  • KStream是一个数据流，可以认为所有的记录都通过Insert only的方式插入进这个数据流中。
  • KTable代表一个完整的数据集，可以理解为数据库中的表。每条记录都是KV键值对，key可以理解为数据库中的主键，是唯一的，而value代表一条记录。我们可以认为KTable中的数据时通过Update only的方式进入的。如果是相同的key，会覆盖掉原来的那条记录。

综上来说，KStream是数据流，来多少数据就插入多少数据，是Insert only；KTable是数据集，相同key只允许保留最新的记录，也就是Update only。

5）窗口

流式数据在时间上无界的，但是聚合操作只能作用在特定(有界)的数据集，这时候就有了窗口的概念，在时间无界的数据流中定义一个边界来用于计算。

⼀个窗⼝包括窗⼝⼤⼩和滑动步长两个属性：

  • 窗⼝⼤⼩：⼀条记录在窗⼝中持续的时间，持续时间超过窗⼝⼤⼩的记录将会被删除；
  • 滑动步长：指定了⼀个窗⼝每次相对于前⼀个窗⼝向前移动的距离

【温馨提示】滑动步长不能超过窗⼝⼤⼩，如果超过窗⼝⼤⼩则会导致部分记录不属于任何窗⼝⽽不被处理。

Kafka Streams定义了三种窗⼝：

  • 跳跃时间窗⼝（hopping time window）：⼤⼩固定，可能会重叠的窗⼝模型
  • 翻转时间窗⼝（tumbling time window）：⼤⼩固定，不可重叠，⽆间隙的⼀类窗⼝模型
  • 滑动窗⼝（sliding window）：⼤⼩固定并且沿着时间轴连续滑动的窗⼝模型，如果两条记录时间戳之差在窗⼝⼤⼩之内，则这两条数据记录属于同⼀个窗⼝。在Kafka流中，滑动窗⼝只有在join操作的时候才⽤到。

三、Kafka Streams原理与架构

Kafka Streams 通过构建 Kafka 生产者和消费者库并利用 Kafka 的本机功能来提供数据并行性、分布式协调、容错和操作简单性，从而简化了应用程序开发。

在这里插入图片描述

1）流分区和任务

Kafka 的消息传递层对数据进行分区以进行存储和传输。Kafka Streams 对数据进行分区以进行处理。在这两种情况下，这种分区是实现数据局部性、弹性、可伸缩性、高性能和容错的原因。Kafka Streams 使用分区和任务的概念作为其基于 Kafka 主题分区的并行模型的逻辑单元。在并行性方面，Kafka Streams 和 Kafka 之间有着密切的联系：

  • 每个流分区是一个完全有序的数据记录序列，并映射到一个 Kafka主题分区。
  • 流中的数据记录映射到来自该主题的 Kafka消息。
  • 数据记录的键决定了 Kafka 和 Kafka Streams 中数据的分区，即数据如何路由到主题内的特定分区。

【例如】如果您的输入主题有 5 个分区，那么您最多可以运行 5 个应用程序实例。这些实例将协作处理主题的数据。如果您运行的应用程序实例数量多于输入主题的分区，“多余”的应用程序实例将启动但保持空闲；但是，如果其中一个繁忙的实例出现故障，则其中一个空闲的实例将恢复前者的工作。

下图显示了两个任务，每个任务分配有输入流的一个分区：

在这里插入图片描述

2）线程模型

Kafka Streams 允许用户配置库可用于并行化应用程序实例中的处理的线程数。每个线程可以使用其处理器拓扑独立地执行一个或多个任务。例如，下图显示了一个流线程运行两个流任务：

在这里插入图片描述启动更多流线程或应用程序的更多实例仅相当于复制拓扑并让它处理不同的 Kafka 分区子集，从而有效地并行处理。值得注意的是，线程之间没有共享状态，因此不需要线程间协调。

3）本地状态存储

  • Kafka Streams 提供了所谓的状态存储，流处理应用程序可以使用它来存储和查询数据，这是实现有状态操作时的重要能力。
  • Kafka Streams 应用程序中的每个流任务都可以嵌入一个或多个本地状态存储，这些本地状态存储可以通过 API 访问，以存储和查询处理所需的数据。Kafka Streams 为此类本地状态存储提供容错和自动恢复。

【例如】Kafka Streams DSL会在您调用有状态运算符（例如join()or aggregate()）或窗口化流时自动创建和管理此类状态存储。

下图显示了两个流任务及其专用的本地状态存储：
在这里插入图片描述

4）容错

Kafka Streams 建立在 Kafka 原生集成的容错功能之上。Kafka 分区具有高可用性和可复制性；因此，当流数据被持久化到 Kafka 时，即使应用程序失败并需要重新处理它，它仍然可用。Kafka Streams 中的任务利用 Kafka 消费者客户端提供的容错能力来处理故障。如果任务在失败的机器上运行，Kafka Streams 会自动在应用程序的剩余运行实例之一中重新启动任务。

四、简单应用（WordCount示例）

官网示例：https://kafka.apache.org/32/documentation/streams/quickstart
源代码：https://github.com/apache/kafka/blob/3.2/streams/examples/src/main/java/org/apache/kafka/streams/examples/wordcount/WordCountDemo.java

1）启动zookeeper和kafka（无鉴权）

$ cd $KAFKA_HOME
$ ./bin/zookeeper-server-start.sh -daemon ./config/zookeeper.properties
$ ./bin/kafka-server-start.sh ./config/server.properties

2）创建topic

创建名为streams-plaintext-input的输入topic和名为streams-wordcount-output的输出topic：

$ cd $KAFKA_HOME
$ bin/kafka-topics.sh --create \
    --bootstrap-server hadoop-node1:19092 \
    --replication-factor 1 \
    --partitions 1 \
    --topic streams-plaintext-input
$ bin/kafka-topics.sh --create \
    --bootstrap-server hadoop-node1:19092 \
    --replication-factor 1 \
    --partitions 1 \
    --topic streams-wordcount-output \
    --config cleanup.policy=compact

【温馨提示】我们创建启用压缩的输出topic，因为输出流是一个变更日志流，对于具有相同键的多条记录，后面的每条记录都是对前一条记录的更新。

查看topic

$ bin/kafka-topics.sh --bootstrap-server hadoop-node1:19092 --describe

3）Maven依赖配置

 <!-- （必需）Kafka 客户端库。包含内置的序列化器/反序列化器 -->
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>3.2.0</version>
</dependency>
<!-- （必需）Kafka Streams 的基础库 -->
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-streams</artifactId>
    <version>3.2.0</version>
</dependency>
<!-- （可选）用于 Scala 库的 Kafka Streams DSL，用于编写 Scala Kafka Streams 应用程序。不使用 SBT 时，您需要在工件 ID 后缀上您的应用程序使用的正确版本的 Scala ( _2.12, _2.13) -->
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-streams-scala_2.13</artifactId>
    <version>3.2.0</version>
</dependency>

4）修改源码

【温馨提示】这里主要修改BOOTSTRAP_SERVERS_CONFIG配置，如果使用带鉴权的kafka就得配置鉴权了。

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.kafka.streams.examples.wordcount;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.kstream.KStream;
import org.apache.kafka.streams.kstream.KTable;
import org.apache.kafka.streams.kstream.Produced;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Locale;
import java.util.Properties;
import java.util.concurrent.CountDownLatch;

/**
 * Demonstrates, using the high-level KStream DSL, how to implement the WordCount program
 * that computes a simple word occurrence histogram from an input text.
 * <p>
 * In this example, the input stream reads from a topic named "streams-plaintext-input", where the values of messages
 * represent lines of text; and the histogram output is written to topic "streams-wordcount-output" where each record
 * is an updated count of a single word.
 * <p>
 * Before running this example you must create the input topic and the output topic (e.g. via
 * {@code bin/kafka-topics.sh --create ...}), and write some data to the input topic (e.g. via
 * {@code bin/kafka-console-producer.sh}). Otherwise you won't see any data arriving in the output topic.
 */
public final class WordCountDemo {

    public static final String INPUT_TOPIC = "streams-plaintext-input";
    public static final String OUTPUT_TOPIC = "streams-wordcount-output";

    static Properties getStreamsConfig(final String[] args) throws IOException {
        final Properties props = new Properties();
        if (args != null && args.length > 0) {
            try (final FileInputStream fis = new FileInputStream(args[0])) {
                props.load(fis);
            }
            if (args.length > 1) {
                System.out.println("Warning: Some command line arguments were ignored. This demo only accepts an optional configuration file.");
            }
        }
        props.putIfAbsent(StreamsConfig.APPLICATION_ID_CONFIG, "streams-wordcount");
        //修改的地方
        props.putIfAbsent(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop-node1:19092,hadoop-node2:19092,hadoop-node3:19092");
        props.putIfAbsent(StreamsConfig.CACHE_MAX_BYTES_BUFFERING_CONFIG, 0);
        props.putIfAbsent(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());
        props.putIfAbsent(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());

        // setting offset reset to earliest so that we can re-run the demo code with the same pre-loaded data
        // Note: To re-run the demo, you need to use the offset reset tool:
        // https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Streams+Application+Reset+Tool
        props.putIfAbsent(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
        return props;
    }

    static void createWordCountStream(final StreamsBuilder builder) {
        final KStream<String, String> source = builder.stream(INPUT_TOPIC);

        final KTable<String, Long> counts = source
            .flatMapValues(value -> Arrays.asList(value.toLowerCase(Locale.getDefault()).split("\\W+")))
            .groupBy((key, value) -> value)
            .count();

        // need to override value serde to Long type
        counts.toStream().to(OUTPUT_TOPIC, Produced.with(Serdes.String(), Serdes.Long()));
    }

    public static void main(final String[] args) throws IOException {
        final Properties props = getStreamsConfig(args);

        final StreamsBuilder builder = new StreamsBuilder();
        createWordCountStream(builder);
        final KafkaStreams streams = new KafkaStreams(builder.build(), props);
        final CountDownLatch latch = new CountDownLatch(1);

        // attach shutdown handler to catch control-c
        Runtime.getRuntime().addShutdownHook(new Thread("streams-wordcount-shutdown-hook") {
            @Override
            public void run() {
                streams.close();
                latch.countDown();
            }
        });

        try {
            streams.start();
            latch.await();
        } catch (final Throwable e) {
            System.exit(1);
        }
        System.exit(0);
    }
}

5）启动 Wordcount 应用程序

在这里插入图片描述

1、在IDEA启动应用程序
2、现在我们可以在一个单独的终端中启动控制台生产者来向这个主题写入一些输入数据：

$ cd $KAFKA_HOME
$ bin/kafka-console-producer.sh --bootstrap-server hadoop-node1:19092 --topic streams-plaintext-input

输入以下数据：
all streams lead to kafka

3、并通过在单独的终端中使用控制台使用者读取其输出topic来检查 WordCount 演示应用程序的输出：

$ cd $KAFKA_HOME
$ bin/kafka-console-consumer.sh --bootstrap-server hadoop-node1:19092 \
    --topic streams-wordcount-output \
    --from-beginning \
    --formatter kafka.tools.DefaultMessageFormatter \
    --property print.key=true \
    --property print.value=true \
    --property key.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
    --property value.deserializer=org.apache.kafka.common.serialization.LongDeserializer

在这里插入图片描述
在这里插入图片描述

6）通过jar包启动程序

将java文件打包成jar包，DIEA打包步骤如下：

  • File->Project Structure->Artifacts
    在这里插入图片描述
  • 在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • Build->Build Artifacts（开始打包）
    在这里插入图片描述
    找到对应的jar包程序，放在$KAFKA_HOME/libs/目录下，运行程序
    在这里插入图片描述
    修改名称
$ mv kafka.jar $KAFKA_HOME/libs/WordCountDemo.jar

运行

$ cd $KAFKA_HOME
# 启动生产者
$ bin/kafka-console-producer.sh --bootstrap-server hadoop-node1:19092 --topic streams-plaintext-input
# 输入以下数据：
hello kafka streams

# 启动应用程序（数据处理，数据统计）
$ bin/kafka-run-class.sh bigdata.kstreams.com.WordCountDemo
# 如果没有修改配置，使用官方提供的以下命令
$ bin/kafka-run-class.sh org.apache.kafka.streams.examples.wordcount.WordCountDemo

# 启动另外一个客户端，显示输出（消费者）
$ bin/kafka-console-consumer.sh --bootstrap-server hadoop-node1:19092 \
    --topic streams-wordcount-output \
    --from-beginning \
    --formatter kafka.tools.DefaultMessageFormatter \
    --property print.key=true \
    --property print.value=true \
    --property key.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
    --property value.deserializer=org.apache.kafka.common.serialization.LongDeserializer

在这里插入图片描述

【总结】Kafka Streams的作用和目的就是数据分析与处理，充当着spark和flink等计算引擎的角色，但是目前企业里把kafka作为计算引擎不多，还是传统用法多（数据缓冲、解耦、异步通信），所以kafka在计算引擎全面化落地还有很长的路要走。期待kafka的一体化实现（数据解耦+数据计算和分析）。

Kafka Streams的介绍就先到这里了，后续会有更全面的kafka API介绍和操作，有疑问的小伙伴，欢迎给我留言哦~

大数据老司机
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
博客
通过 docker-compose 快速部署 Flink 保姆级教程
04-14 835
Apache Flink 是一个开源的流处理框架，用于处理和分析实时数据流。它支持事件驱动的应用和复杂的事件处理（CEP），并且可以处理批处理任务。Flink 提供了高吞吐量、低延迟以及强大的状态管理和容错能力。它可以在各种环境中运行，包括本地集群、云环境和容器化环境（如 Docker 和 Kubernetes）。文末有Flink高吞吐量和低延迟：Flink 能够处理大规模的数据流，同时保持毫秒级的处理延迟。状态管理和容错：Flink 提供了强大的状态管理功能，允许在发生故障时从检查点或保存点恢复作业。
博客
Raft Kafka on k8s 部署实战操作
03-24 1040
部署 Raft Kafka（Kafka 3.3.1 及以上版本引入的 KRaft 模式）在 Kubernetes (k8s) 上，可以简化 Kafka 集群的管理，因为它不再依赖于 Zookeeper。
博客
Prometheus 基于 Consul 实现服务自动发现注册
03-17 1057
Prometheus与Consul集成可以实现服务的自动发现和注册。Consul 是一个服务发现和配置的工具，它可以管理服务的注册、发现和健康检查。Prometheus可以通过Consul的服务发现功能来动态地发现监控目标（Targets）。
博客
深度解析 Raft 协议与KRaft实战演示
03-10 645
Raft 协议是一种分布式一致性算法，它用于在分布式系统中的多个节点之间达成一致性。Raft 协议的目标是提供一种相对简单、易于理解和实现的方法，以确保在网络分区、节点故障等情况下，系统仍然能够保持一致性和可用性。
博客
为何Kafka在2.8版本开始会“抛弃”Zookeeper？
03-03 1312
Kafka被官方定义为分布式流式处理平台，因为具备高吞吐、可持久化、可水平扩展等特性而被广泛使用。
博客
OpenResty 介绍与实战讲解（nginx&lua）
02-18 1188
OpenResty是一个基于 Nginx与Lua的高性能Web平台，其内部集成了大量精良的Lua库、第三方模块以及大多数的依赖项。用于方便地搭建能够处理超高并发、扩展性极高的动态Web应用、Web服务和动态网关。简单地说OpenResty的目标是让你的Web服务直接跑在 Nginx 服务内部，充分利用 Nginx 的非阻塞 I/O 模型，不仅仅对 HTTP 客户端请求,甚至于对远程后端诸如 MySQL、PostgreSQL、Memcached 以及 Redis 等都进行一致的高性能响应。Nginx。
博客
lua 语法介绍与 NGINX lua 高级用法实战操作
02-03 1318
lua是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放，其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。
博客
NGINX 实战操作（yarn-proxy）
01-28 1265
NGINX 代理是非常常见的，内网生成环境一般不让在本机直接访问，这时候就得利用代理，但是一般代理就得脱敏或去掉页面上的高危操作。这里就拿 YARN 代理来讲解。这里也会涉及到 subs_filter 讲解。
博客
NGINX sub_filter和subs_filter 指令讲解
01-21 1240
在 NGINX 中，sub_filter 和 subs_filter 是两个用于替换响应内容中字符串的指令，它们主要用于反向代理和修改响应内容。
博客
NGINX 路由配置与参数详解（https配置、跨域配置、socket配置）
01-14 2087
Nginx 是一个高性能的开源Web服务器，也可以用作反向代理服务器、负载均衡器和HTTP缓存。它的设计目标是提供高并发、低内存消耗和高度可伸缩性，使其成为处理大量并发连接的理想选择。
博客
NGINX - 高级负载均衡器、Web服务器、反向代理
01-07 595
Nginx 是一个高性能的开源Web服务器，也可以用作反向代理服务器、负载均衡器和HTTP缓存。它的设计目标是提供高并发、低内存消耗和高度可伸缩性，使其成为处理大量并发连接的理想选择。
博客
Hadoop YARN Cgroups 资源隔离讲解
12-24 1239
Hadoop YARN (Yet Another Resource Negotiator) 使用 Cgroups（Control Groups）来进行资源管理和隔离。Cgroups 是 Linux 内核提供的一种机制，用于限制、账户和隔离进程组（process groups）的资源（例如 CPU、内存、磁盘 I/O 等）
博客
Apache Kyuubi 讲解与实战操作
12-20 1386
Apache Kyuubi，一个分布式多租户网关，用于在 Lakehouse 上提供无服务器 SQL。Kyuubi 是一个基于 Apache Spark 的开源分布式 SQL 引擎，为用户提供了一个统一的 SQL 查询接口，使其能够以标准 SQL 语法查询和分析各种数据源。
博客
通过 docker-compose 快速部署 EFAK 保姆级教程
12-10 687
EFAK（Eagle For Apache Kafka，以前称为 Kafka Eagle）是一款由国内公司开源的Kafka集群监控系统，可以用来监视kafka集群的broker状态、Topic信息、IO、内存、consumer线程、偏移量等信息，并进行可视化图表展示。独特的KQL还可以通过SQL在线查询kafka中的数据。
博客
Java 内存分析工具 Arthas 介绍与示例讲解
12-04 2803
Arthas（阿尔萨斯）是阿里巴巴开源的一款Java诊断工具，用于实时检测、诊断Java应用程序的性能问题。它是一个命令行工具，提供了丰富的功能，包括查看类加载信息、方法执行耗时、线程堆栈、内存分析等。Arthas的设计目标是在生产环境中实时诊断和解决Java应用程序的问题。以下是Arthas实时性Arthas可以在运行中的Java进程中实时进行诊断，无需重新启动应用。丰富的命令： 提供了众多的命令，涵盖了类加载、方法执行、线程、内存、GC等多个方面。动态追踪。
博客
dump 日志收集与分析（jmap 和 jstack 工具）讲解与实战操作
12-03 3797
dump通常指的是从一个系统或应用程序中生成一份详细的信息快照，以便进行调试、分析或故障排除。在不同的上下文中，dump可能指的是不同类型的信息。内存转储）：内存转储是将程序的内存内容以二进制形式保存到文件中的过程。这对于在程序崩溃或发生问题时进行调试和分析非常有用。常见的工具有 gcore（用于 GDB）、jmap（用于 Java 应用程序）等。核心转储（Core Dump）：核心转储是在程序崩溃时生成的一个包含程序当前内存状态的文件。它通常包括内存、寄存器和堆栈信息。
博客
通过 docker-compose 快速部署 Rancher 保姆级教程
11-26 1382
Rancher是一个开源的容器管理平台，它为企业提供了一个简化容器化应用部署、管理和扩展的工具。Rancher提供了一套完整的容器服务堆栈，支持Docker和Kubernetes，并且可以在任何基础设施上运行，包括物理服务器、虚拟机、公有云和私有云。以下是Rancher多集群管理Rancher允许您集中管理多个Kubernetes集群、集群和独立的Docker容器。这使得在多云、混合云和多地理位置的环境中管理和部署容器化应用变得更加简便。用户和权限管理Rancher。
博客
开源数据收集引擎 Logstash 讲解和示例讲解
11-20 469
Logstash 是一个开源的数据收集和日志处理工具，它是 Elastic Stack（ELK Stack）的一部分，用于从各种数据源中采集、转换和传输数据，以帮助分析和可视化大规模数据。Logstash 通常与 Elasticsearch 和 Kibana 一起使用，以实现实时日志分析和监控。
博客
kafka 磁盘扩容与数据均衡实在操作讲解
11-19 503
Kafka 的磁盘扩容和数据均衡是与保证Kafka集群可用性和性能相关的两个重要方面。在 Kafka 中，分区数据的存储和平衡对集群的运行至关重要。
博客
容器日志采集的三种方式实战操作讲解（Filebeat）
11-12 963
Filebeat 是一个轻量级的开源数据采集器，通常用于从不同来源收集和发送日志和事件数据。在 Kubernetes 或 Docker 环境中，Filebeat 常用于采集容器的日志。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值