Kafka: 分布式流平台入门之安装、配置

【Kafka基础】单机安装与配置指南,从零搭建环境 学习Kafka,掌握Kafka的单机部署是理解其分布式特性的第一步。本文将手把手带你完成Kafka单机环境的安装、配置及基础验证,涵盖常见问题排查技巧。 阅读详情

Kafka 核心概念与定位


关键纠正:
Kafka 不是传统消息队列,而是 分布式流处理平台(Apache 官方定义)。其核心差异在于:

  1. 设计目标:支撑高吞吐、低延迟的实时数据流处理(如对接 Spark/Flink),而非单纯消息传递。
  2. 核心特性:
    • 高吞吐量:单集群可处理百万级消息/秒。
    • 持久化存储:消息按分区(Partition)顺序写入磁盘,支持回溯消费。
    • 流处理能力:原生集成 Kafka Streams API,支持复杂事件处理。

其核心差异:

特性传统消息队列Kafka 流平台
设计目标应用解耦/异步通信高吞吐实时流处理
吞吐量万级 TPS百万级 TPS
数据保留消费后删除持久化存储+回溯
典型应用任务队列实时分析/ETL/监控

技术背景:

  • 起源:LinkedIn 基于 Scala 开发,专为大数据场景优化

  • 核心特性:

    • 分布式架构:依赖 Zookeeper 协调
    • 高吞吐低延迟:顺序磁盘 I/O + 零拷贝技术
    • 流处理能力:原生支持 Spark/Flink 集成
  • 关键认知:Kafka 可被 用作 消息中间件,但本质是流处理基础设施。其 日志存储结构 和 分区机制 是支撑实时数据管道的核心。

传统消息队列(如 RabbitMQ)更侧重消息路由、事务一致性,而 Kafka 专注流数据管道构建。

环境安装与配置


  1. 前置依赖
  • JDK 1.8+:Kafka(Scala 开发)和 ZooKeeper(Java)的运行基础。
  • ZooKeeper 3.6+:管理 Kafka 集群元数据(Broker、Topic、分区状态)。
  • Kafka 2.8+:推荐版本(原文 2.4.0 过旧,已升级)。
  1. 安装步骤

JDK 配置

# 解压 JDK 至 /opt/install  
tar -zxvf jdk-8u371-linux-x64.tar.gz -C /opt/install  
 
# 配置环境变量(/etc/profile)  
export JAVA_HOME=/opt/install/jdk1.8.0_371  
export PATH=$PATH:$JAVA_HOME/bin  
 
# 生效配置  
source /etc/profile  
java -version  # 验证安装

ZooKeeper 配置

# 解压并修改配置文件(zoo.cfg)  
tar -zxvf apache-zookeeper-3.6.3-bin.tar.gz -C /opt/install  
cd /opt/install/apache-zookeeper-3.6.3-bin/conf  
cp zoo_sample.cfg zoo.cfg  
 
# 关键配置项  
dataDir=/var/lib/zookeeper  # 生产环境需独立磁盘目录  
clientPort=2181  
 
# 启动 ZooKeeper  
bin/zkServer.sh start  
bin/zkCli.sh -server 127.0.0.1:2181  # 验证连接

Kafka 配置

# 解压并修改 server.properties  
tar -zxvf kafka_2.13-2.8.1.tgz -C /opt/install  
cd /opt/install/kafka_2.13-2.8.1/config  
 
# 关键配置项  
listeners=PLAINTEXT://192.168.1.100:9092  # 替换为服务器IP  
advertised.listeners=PLAINTEXT://192.168.1.100:9092  
log.dirs=/var/log/kafka  # 生产环境需大容量磁盘  
zookeeper.connect=localhost:2181  # ZooKeeper 地址  
 
# 启动 Kafka  
bin/kafka-server-start.sh config/server.properties

# 基础功能验证
kafka-topics.sh --list --bootstrap-server 192.168.1.100:9092

基础操作与验证


1 ) Kafka 控制台命令

功能命令
创建 Topicbin/kafka-topics.sh --create --topic test-topic --partitions 3 --replication-factor 1 --bootstrap-server 192.168.1.100:9092
生产消息bin/kafka-console-producer.sh --topic test-topic --bootstrap-server 192.168.1.100:9092
消费消息bin/kafka-console-consumer.sh --topic test-topic --from-beginning --bootstrap-server 192.168.1.100:9092
查看 Topic 列表bin/kafka-topics.sh --list --bootstrap-server 192.168.1.100:9092

2 ) 存储机制解析

  • 分区(Partition):Topic 被拆分为多个分区,实现并行处理。
  • 分段日志(Segment Log):每个分区由多个 *.log 文件组成,避免单文件过大。
  • 偏移量(Offset):消息在分区内的唯一 ID,消费者据此定位读取位置。

工程示例:1


1 )方案 1:原生 KafkaJS 驱动

// 安装依赖:npm install kafkajs
import { Kafka } from 'kafkajs';
 
const kafka = new Kafka({
  brokers: ['192.168.1.100:9092'],
});
 
// 生产者
const producer = kafka.producer();
await producer.connect();
await producer.send({
  topic: 'test-topic',
  messages: [{ value: 'Hello Kafka from NestJS!' }],
});
 
// 消费者
const consumer = kafka.consumer({ groupId: 'test-group' });
await consumer.connect();
await consumer.subscribe({ topic: 'test-topic' });
await consumer.run({
  eachMessage: async ({ message }) => {
    console.log(`Received: ${message.value.toString()}`);
  },
});

2 ) 方案 2:NestJS 官方 @nestjs/microservices 模块

// app.module.ts
import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
 
@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'KAFKA_SERVICE',
        transport: Transport.KAFKA,
        options: {
          client: {
            brokers: ['192.168.1.100:9092'],
          },
          consumer: {
            groupId: 'nestjs-group',
          },
        },
      },
    ]),
  ],
})
export class AppModule {}
 
// producer.service.ts 
import { Inject, Injectable } from '@nestjs/common';
import { ClientKafka } from '@nestjs/microservices';
 
@Injectable()
export class ProducerService {
  constructor(@Inject('KAFKA_SERVICE') private client: ClientKafka) {}
 
  async sendMessage(topic: string, message: string) {
    this.client.emit(topic, { value: message });
  }
}
 
// consumer.controller.ts
import { Controller, Post } from '@nestjs/common';
import { EventPattern, Payload } from '@nestjs/microservices';
 
@Controller()
export class ConsumerController {
  @EventPattern('test-topic')
  handleMessage(@Payload() message: { value: string }) {
    console.log(`Consumed: ${message.value}`);
  }
}

3 ) 方案 3:Schema Registry 集成(Avro 序列化)

// 安装依赖:npm install @kafkajs/confluent-schema-registry avsc
import { Kafka } from 'kafkajs';
import { SchemaRegistry } from '@kafkajs/confluent-schema-registry';
 
const registry = new SchemaRegistry({ host: 'http://schema-registry:8081' });
const kafka = new Kafka({ brokers: ['192.168.1.100:9092'] });
 
// 发送 Avro 格式消息
const producer = kafka.producer();
const { id } = await registry.register({
  type: 'record',
  name: 'Message',
  fields: [{ name: 'content', type: 'string' }],
});
await producer.send({
  topic: 'avro-topic',
  messages: [
    { 
      value: await registry.encode(id, { content: 'Schema-enabled message' }) 
    },
  ],
});
 
// 消费并解码 Avro 消息
const consumer = kafka.consumer({ groupId: 'avro-group' });
await consumer.run({
  eachMessage: async ({ message }) => {
    const decoded = await registry.decode(message.value);
    console.log(`Decoded: ${decoded.content}`);
  },
});

工程示例:2


1 ) 方案 1:基础生产者-消费者


// producer.service.ts  
import { Injectable } from '@nestjs/common';
import { Kafka, Producer, ProducerRecord } from 'kafkajs';
 
@Injectable()
export class KafkaProducerService {
  private producer: Producer;
 
  constructor() {
    const kafka = new Kafka({
      brokers: ['192.168.1.10:9092'],
    });
    this.producer  = kafka.producer(); 
  }
 
  async sendMessage(topic: string, message: string) {
    await this.producer.connect(); 
    const record: ProducerRecord = {
      topic,
      messages: [{ value: message }],
    };
    await this.producer.send(record); 
  }
}
 
// consumer.service.ts 
import { Injectable } from '@nestjs/common';
import { Kafka, ConsumerRunConfig } from 'kafkajs';
 
@Injectable()
export class KafkaConsumerService {
  private consumer;
 
  constructor() {
    const kafka = new Kafka({
      brokers: ['192.168.1.10:9092'],
    });
    this.consumer  = kafka.consumer({  groupId: 'test-group' });
  }
 
  async subscribe(topic: string, callback: (message: string) => void) {
    await this.consumer.connect(); 
    await this.consumer.subscribe({  topic });
    const runConfig: ConsumerRunConfig = {
      eachMessage: async ({ message }) => {
        callback(message.value.toString()); 
      },
    };
    await this.consumer.run(runConfig); 
  }
}

2 ) 方案 2:事务消息保障

// 创建支持事务的 Kafka 生产者
const producer = kafka.producer({ 
  transactionTimeout: 30000,  // 事务超时时间(毫秒)
});
 
// 执行事务操作 
await producer.transaction().run(async  ({ send }) => {
  // 1. 发送 Kafka 消息
  await send({
    topic: 'orders',
    messages: [{ value: 'Order_Created' }], 
  });
 
  // 2. 执行业务逻辑(如数据库操作)
  await databaseService.createOrder(); 
  
  // 事务自动提交(成功)或回滚(失败)
});

3 ) 方案 3:Schema Registry 集成(Avro 协议)

import { SchemaRegistry } from '@kafkajs/confluent-schema-registry';
 
// 注册 Avro Schema 
const registry = new SchemaRegistry({ 
  host: 'http://schema-registry:8081' 
});
 
const schema = `{
  "type": "record",
  "name": "Payment",
  "fields": [
    { "name": "amount", "type": "double" }
  ]
}`;
 
// 注册 Schema 并获取 ID
const id = await registry.register({  
  type: 'AVRO', 
  schema 
});
 
// 编码消息
const payload = { amount: 99.99 };
const encodedValue = await registry.encode(id,  payload);
 
// 发送带 Schema 的消息
await producer.send({ 
  topic: 'payments',
  messages: [
    { value: encodedValue }
  ]
});

工程示例:3


1 ) 方案 1:基础生产者-消费者

// producer.service.ts 
import { Injectable } from '@nestjs/common';
import { Client, Producer, ProducerRecord } from 'kafkajs';@Injectable() 
export class KafkaProducer {
  private producer: Producer;
  constructor() { 
    const kafka = new Client({
      brokers: ['192.168.1.100:9092'],
    }); 
    this.producer = kafka.producer();
  } 

  async sendMessage(topic: string, message: string) {
    await this.producer.connect();
    const record: ProducerRecord = {
      topic,
      messages: [{ value: message }],
    };    await this.producer.send(record);
  } 
}

// consumer.service.ts
import { Injectable, OnModuleInit } from '@nestjs/common';
import { Consumer, Kafka } from 'kafkajs';

@Injectable()
export class KafkaConsumer implements OnModuleInit {
  private consumer: Consumer;

  constructor() {
    const kafka = new Kafka({ brokers: ['192.168.1.100:9092'] });
    this.consumer = kafka.consumer({ groupId: 'nestjs-group' });
  }

  async onModuleInit() {
    await this.consumer.connect();
    await this.consumer.subscribe({ topic: 'test-topic', fromBeginning: true });
    this.consumer.run({ 
      eachMessage: async ({ message }) => {
        console.log(`Received: ${message.value.toString()}`);
      }, 
    });
  }}

2 ) 方案 2:事务性消息传递

// transactional.producer.ts
async sendTransactionalMessage(topic: string, messages: string[]) {
  const transaction = await this.producer.transaction();
  try {    await transaction.send({ 
      topic,
      messages: messages.map(msg => ({ value: msg })),
    });    await transaction.commit(); 
  } catch (error) {    await transaction.abort();    throw error; 
  }
}

3 ) 方案 3:流处理集成(KafkaJS + Node.js Streams)

import { Stream } from 'kafkajs';
 
async createTopicStream(topic: string) {
  const stream = await Stream(this.consumer, { topics: [topic] });
  stream.on('data', ({ message }) => {
    // 流式数据处理逻辑
    this.processData(message.value.toString());
  });
}
) {
  // 实现实时数据分析/转换逻辑 
}

架构设计注意事项


  1. 生产环境配置:

    • 数据目录分离:log.dirs 挂载独立 SSD 磁盘阵列
    • Zookeeper 集群:至少 3 节点避免脑裂
    • 副本机制:replication.factor ≥ 2 + min.insync.replicas=1
  2. NestJS 最佳实践:

    • 连接池管理:复用 Kafka 客户端实例
    • 错误处理:实现 retry 机制 + DLQ(死信队列)
    • 性能优化:启用 compression.type=snappy
  3. 流处理扩展:

    • 集成 Kafka Streams API 实现实时 ETL
    • 使用 ksqlDB 构建流式 SQL 查询
    • 监控方案:Prometheus + Grafana 看板

初学者提示:分区(Partition)是 Kafka 并行处理的基本单元,消费者组(Consumer Group)中每个分区仅被一个消费者处理,实现水平扩展。

生产环境关键配置


  1. Kafka 集群:
    • broker.id 唯一标识每个节点
    • num.network.threads=8 提高网络吞吐
    • default.replication.factor=3 确保数据冗余
  2. ZooKeeper 集群:
    • 至少 3 节点部署,避免单点故障
    • tickTime=2000 与 initLimit=10 控制节点同步
  3. NestJS 优化:
    • 使用 kafkajs 的 compression 参数减少带宽占用
    • 通过 batch 配置合并发送消息提升吞吐

注意:原文中所有 Java/Spring Boot 技术栈已替换为 NestJS 等效实现,确保技术栈一致性。

常见问题排查


  • 连接失败:检查 advertised.listeners 是否暴露正确 IP
  • 消息堆积:增加消费者组并行度(partitions > consumers)
  • 数据丢失:设置 acks=all 确保消息持久化

生产环境最佳实践


  1. 磁盘优化:
    • 使用多块 SSD 挂载不同 log.dirs 目录提升 IO 并行度
  2. 网络配置:
    properties # server.properties 关键参数 socket.send.buffer.bytes=1024000 # 调优发送缓冲区 socket.request.max.bytes=104857600 # 允许最大消息 100MB 3. 监控集成:
    • Prometheus + Grafana 监控指标(消息堆积率/网络延迟)
    • Kafka Manager 可视化集群状态

关键检查点:

  • 使用 kafka-topics.sh --list --bootstrap-server localhost:9092 验证 Topic 列表
  • 通过 kafka-console-consumer.sh 实时调试消息流

总结与进阶方向


Apache Kafka 作为分布式流处理平台,其核心价值在于 实时数据管道 与 事件驱动架构 的实现。

后续可深入:

  1. 流处理框架集成:Kafka Streams 或 Flink 实时计算
  2. Exactly-Once 语义:通过 enable.idempotence=true 保障数据精准一次
  3. KRaft 模式:Zookeeper 替代方案(Kafka 2.8+)

📚 学习资源推荐:

kafka 的安装 kafka 单机版安装教程,没有那么多废话 阅读详情

相关推荐

Kafka详解

consumer 提交offset的时候,kafka Offset manager会首先追加一条新的conmit消息到 _consumer_offset topic中,然后更新对应的缓存,读offset时从缓存中读取,而不是直接读取 _consumer_offset topic。如查找368801的offset消息。同一个Topic的每个分区中的数据是不重复的,partition的表现形式是一个一个文件夹。文件,每个 .log文件 的大小是一样的,但是里面存储的消息条数可能不相同(可能消息的大小不一致)。

qq_41644412的博客 6849

Kafka-安装和配置(搭建环境)

在开始之前,我们先理清一个关键背景:Kafka 正在经历一个重要的架构演进——逐步移除对 ZooKeeper 的依赖,转向自研的 KRaft (Kafka Raft) 模式。这不仅是安装方式的差异,更代表了Kafka未来的架构方向,理解这一点对你后续的学习和选型很有帮助。为适应新版本的变化,本文以KRaft (Kafka Raft) 模式进行讲解。

qq_50847694的博客 313

Kafka 详解:全面解析分布式流处理平台

Apache Kafka 是一个分布式流处理平台,主要用于构建实时数据管道和流式应用。它具有高吞吐量、低延迟、高可用性和高可靠性的特点,广泛应用于日志收集、数据流处理、消息系统、实时分析等场景。

微笑听雨 6122

Kafka学习笔记

本文转载来自:https://www.cnblogs.com/qingyunzong/p/9004703.html Kafka是Apache下的一个子项目,是一个高性能跨语言分布式发布/订阅消息队列系统,图展示了Kafka的相关术语以及之间的关系 上图一个topic配置了3个partition。Partition1有两个offset:0和1。Partition2有4个offs...

weixin_30650859的博客 2094

Kafka 在 Linux 下的集群配置和安装

本文详细介绍了在 Linux 环境中配置和安装 Kafka 集群的过程,包括每个配置项的说明和常见故障的排查方法。通过这些步骤,您可以轻松地构建一个可靠的 Kafka 集群,支持大规模数据流处理和实时数据传输。希望这篇文章能够帮助您顺利搭建和管理 Kafka 集群。

J老熊 2715

Kafka使用教程和案例详解

本文详细介绍了 Kafka 的基本概念、安装配置、使用教程以及实际应用案例。Kafka 作为一个高性能的分布式消息系统,广泛应用于实时数据处理、日志收集、消息队列等领域。通过本文的介绍,相信读者可以掌握 Kafka 的基本使用方法,并能够在实际项目中应用 Kafka 提高数据处理能力。通过配置和使用 Kafka,开发者可以构建高效、可靠的流处理系统,满足各种实时数据处理需求。版权声明:原创博主:牛哄哄的柯南[哈哈][抱拳]加油!共同努力!Keafmd牛哄哄的柯南,期待你的。

『愚』的博客 9365

Kafka (快速)安装部署

进行下载,Scala 2.12 和 Scala 2.13 主要是使用Scala编译的版本不同,两者皆可。接下来我们还需要在每个 zookeeper 节点的数据目录下创建对应的服务id文件与上面配置的。针对每个节点修改主机名称,查看当前主机的ip地址并固定,添加子网掩码,网关,DNS1。Kafka一般情况下都是分布式架构的,单机节点的使用情况基本不存在——了解即可。当然,也可以只安装并配置一台zookeeper,然后将整个软件拷贝过去。环境变量,以及将$ZK_HOME/bin文件夹加入PATH环境变量中。

m0_62943934的博客 2万+

Apache Kafka——分布式流处理平台

Apache Kafka是一种高吞吐量、低延迟、可扩展且 fault-tolerant 的分布式流处理平台。它最初由LinkedIn开发并开源,是一个多用途的分布式消息系统,可以用于构建实时数据管道和流处理应用。支持多语言客户端提供了基于发布/订阅模式的消息分发机制提供了强大的持久性保证,支持水平扩容在内部实现了消费者组功能,允许多个消费者消费相同的数据内置了大量的工具和组件,包括命令行、监控指标、SQL代理等。本文将详细介绍Apache Kafka及其特性。

AI天才研究院 924

Kafka 入门:从消息队列到分布式流平台的转变

Kafka 是一个分布式流平台,用于处理和存储大规模的实时数据流。它的原始目的是作为一个高吞吐量的消息队列,但随着需求的演进,它逐渐演变成了一个流处理平台,能够处理来自不同数据源的数据流并进行实时分析。Producer:生产消息的客户端。Consumer:消费消息的客户端。Broker:消息存储和处理的服务器。Zookeeper:协调服务,用于管理集群的元数据、节点信息等。Kafka 的架构采用了分布式设计,集群由多个 Broker 组成。

一碗黄焖鸡三碗米饭的博客 969

全面掌握Kafka:安装、配置与集群扩展

Apache Kafka是LinkedIn开发的分布式流处理平台,专门用于构建实时数据管道和流应用程序。它被设计为可水平扩展、高吞吐量的发布-订阅消息系统,能够处理大量的实时数据。Kafka服务可以通过命令行启动。以下是启动Kafka服务的基本命令:Zookeeper是一个开源的分布式协调服务,它为分布式应用提供一致性服务,如命名、配置管理、同步和群组服务。在Kafka集群中,Zookeeper扮演着至关重要的角色。

weixin_28933797的博客 768

全面掌握Kafka分布式流处理平台课程讲义

本文还有配套的精品资源,点击获取 简介:Apache Kafka是一款高吞吐量的分布式发布订阅消息系统,本课程讲义详细涵盖了其核心概念、安装配置、架构解析、API使用以及监控与面试知识点。课程分章节介绍了Kafka的安装和使用流程,深入解析了其核心架构与组件,并详细介绍了Java和Scala客户端库的API使用方法,最后提供了监控和面试相关知识。通过学习,学习者将能全面理解...

weixin_35752122的博客 1141

分布式流处理平台(Apache Kafka)

Apache Kafka:分布式流处理平台,可用于实时数据集成和流数据处理。支持高吞吐量的数据传输和处理,适用于实时数据分析和事件驱动架构。最初由LinkedIn开发并开源,于2011年开始投入使用,后来成为Apache软件基金会的一个顶级项目。其设计初衷是为了满足LinkedIn公司内部对大规模实时数据处理和传输的需求。

weixin_43156294的博客 1496

秋叶ComfyUI整合包:一键部署AI绘画工作流,解决环境配置难题

在AI绘画和生成式AI领域,Stable Diffusion作为开源的扩散模型,为图像生成提供了强大的技术基础。其核心原理是通过学习数据分布,对随机噪声进行逐步去噪,最终生成高质量的图像。这项技术的价值在于极大地降低了专业图像创作的门槛,并推动了AIGC(人工智能生成内容)在艺术设计、游戏开发、广告营销等场景的广泛应用。然而,其典型工作流实现工具ComfyUI,在实际部署中常因Python环境、PyTorch版本与CUDA驱动之间的复杂依赖关系而受阻,尤其是面对NVIDIA 30系、40系及未来50系等不同

优快云头条 675

探索 Kafka:强大的分布式流处理平台

在当今大数据和实时数据处理的时代,Apache Kafka 已然成为了众多开发者和企业的得力工具。今天,就来深入了解一下 Kafka 究竟是什么,以及如何安装并上手使用它。

weixin_64773949的博客 969

SAP 接口测试操作-业务顾问

业务顾问测试接口操作

weixin_43657667的博客 5164

aruco_ros实战:从USB摄像头到Marker位姿检测全流程解析

本文详细解析了使用aruco_ros从USB摄像头实现ArUco Marker检测与位姿估计的全流程。内容涵盖环境搭建、核心launch文件配置、可视化调试、位姿数据解析以及深度优化技巧,帮助开发者快速掌握ROS下的视觉定位关键技术,并集成到机器人项目中。

weixin_29230805的博客 265

Kafka 入门篇Apache Kafka 是一个开源的分布式流平台,常用于构建实时数据流处理系统。它原本由 LinkedIn 开发,并在 2011 年成为 Apache 基金会的一部分。Kafka

Kafka 是一个非常强大的分布式流平台,适合用来处理高吞吐量的消息流。在大数据处理、实时分析、日志收集等领域,Kafka 都有着广泛的应用。通过本教程,你应该已经掌握了 Kafka 的基础概念、安装与配置过程,以及如何创建主题、生产消息和消费消息。如果你希望进一步了解 Kafka 的高级特性,可以深入研究 Kafka 的文档和源码。

m0_58223765的博客 1556

uniapp实战:mui-player插件如何完美适配m3u8/flv直播流(附完整代码)

本文详细介绍了如何在Uniapp中使用mui-player插件完美适配m3u8和flv直播流,提供从基础配置到高级优化的全流程解决方案。通过动态加载策略、响应式布局和内存管理,实现跨平台稳定播放,适用于企业级直播应用开发。

weixin_29001655的博客 237

【kafka】Centos7安装kafka

一、前言 前一段时间在通知系统中,用到了kafka,刚开始的时候是通过本地安装的kafka来运行的,本地安装的kafka。后来在项目中,使用的是阿里的kafka,阿里的也是今年8月开始推出的。这里先记录一下本地安装kafka的过程。 二 、kafka介绍 kafka,先说说小编最初认识是在学习mq的时候,当时知道使用的mq有很多种,rocketmq,rabbitmq等等。后来在项目中选择了rabb...

哈士奇 3万+

NVIDIA Tao Toolkit环境配置踩坑

请搭配食用该文章为 Tao 安装中可能出现的问题进行解答,如果存在本文章中没出现的问题,欢迎提问,由我复现后更新文章。由于大部分云服务器厂商不能支持 docker,因此我使用的环境为2023年5月27日在平台租的 3080 旧版环境进行实验。

qq_36630208的博客 773

【人工智能之深度学习】23. 推荐系统升级实战:LightGCN重构协同过滤全流程(Amazon-Beauty数据集+完整代码)

摘要:传统协同过滤(如矩阵分解)在电商推荐中存在三大痛点:忽略用户-物品高阶关联、交互数据稀疏导致冷启动、特征工程依赖人工设计。本文基于Amazon-Beauty数据集(含20万+用户交互),用LightGCN图神经网络重构推荐系统:1)构建用户-物品二部图,通过3层图卷积捕捉“用户→物品→用户”的多跳关联;2)采用BPR负采样损失优化嵌入学习,缓解数据稀疏;3)端到端输出用户/物品嵌入,无需人工特征。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1498

Linux平台Kafka高可用集群部署全攻略

本文详细介绍了如何在CentOS 7环境下搭建高可用的Kafka集群。Kafka是一个分布式流处理平台,常用于构建实时数据流管道和流应用程序。为了确保Kafka的高可用性和容错性,集群搭建是必不可少的步骤。 首先,介绍了环境准备,包括服务器准备(至少需要三台服务器或虚拟机)和版本信息(Kafka 2.13-3.x.x版本,JDK 1.8+)。在搭建Kafka集群之前,需要先安装和配置JDK和ZooKeeper。JDK的安装包括下载和解压压缩包,配置环境变量,并验证安装是否成功。ZooKeeper的安装和配

博客虽小,世界尽在其中 1万+

MATLAB船舶开尔文尾迹三维仿真建模

开尔文尾迹介绍 Kelvin最早研究舰船在水面运动在水面上形成波纹的原理,主要针对静水中点源运动的尾迹问题,并给出尾迹的张角和波高分布情况。由 Kelvin 的理论,一般情况下假设由一个理想点源来代替舰船,开尔文尾迹由分歧波和横断波组成,分歧波向船的两侧扩散,而横断波主要向船的后方传播,在相遇的地方两波相干形成尖头波,且尖头波位于尾迹角16°到19.5°之间,又因为尖头波波长过短,以至于无法单独的区分出每个尖头波的波前,所有的波前在视觉效果上就连成一条直线表现为亮线,称为开尔文臂,开尔文臂以船身对称,且角度

qq_19512613的博客 3848

Kafka分布式流处理平台安装与配置指南

分布式流处理平台是现代大数据架构中的核心组件,通过发布-订阅模式实现高吞吐、低延迟的消息处理。Kafka作为其中的佼佼者,其核心原理基于分布式日志存储和消费者组机制,能够有效处理实时数据管道、事件驱动架构等场景。在工程实践中,Kafka的安装配置涉及ZooKeeper协调服务、Broker节点设置等关键环节,合理的JVM调优和OS参数配置可显著提升性能。本文以Kafka 3.7.0为例,详细演示从单机部署到集群配置的全流程,特别强调生产环境中必须注意的日志路径设置、副本因子配置等最佳实践,帮助开发者快速搭建

weixin_33309048的博客 247

计算机视觉卷积神经网络(CNN)基础:从LeNet到ResNet

计算机视觉卷积神经网络(CNN)基础:从LeNet到ResNet,在计算机视觉领域,卷积神经网络(Convolutional Neural Network,CNN)已然成为推动众多任务发展的核心力量。从早期简单的图像识别,到如今复杂的目标检测、语义分割、图像生成等任务,CNN 都展现出了卓越的性能。CNN 的发展历程见证了一系列经典模型的诞生,其中 LeNet 作为开山之作,为 CNN 的发展奠定了基础,而 ResNet 则通过创新性的设计,突破了传统神经网络的限制,使得网络能够构建得更深、性能更优。

不踩坑,不知道坑有多深;不总结,踩过的坑白踩。 14万+

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

Kafka分布式流处理平台简介

Kafka是数据大动脉

Lown_1的博客 1214

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

上一篇: Kafka:流处理平台入门之环境准备、核心概念与工程
下一篇: Kafka: 从客户端API到事务消息的工程实践
Wang's Blog
博客等级 码龄12年 7441粉丝 2427原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值