This is the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

HugeGraph Computing (OLAP)

1: HugeGraph-Vermeer Quick Start
2: HugeGraph-Computer Quick Start
3: HugeGraph-Computer 配置参考

DeepWiki 提供实时更新的项目文档，内容更全面准确，适合快速了解项目最新情况。
📖 https://deepwiki.com/apache/hugegraph-computer

GitHub 访问： https://github.com/apache/hugegraph-computer

1 - HugeGraph-Vermeer Quick Start

一、Vermeer 概述

1.1 运行架构

Vermeer 是一个 Go编写的高性能内存优先的图计算框架 (一次启动，任意执行)，支持 15+ OLAP 图算法的极速计算 (大部分秒~分钟级别完成执行)，包含 master 和 worker 两种角色。master 目前只有一个 (可增加 HA)，worker 可以有多个。

master 是负责通信、转发、汇总的节点，计算量和占用资源量较少。worker 是计算节点，用于存储图数据和运行计算任务，占用大量内存和 cpu。grpc 和 rest 模块分别负责内部通信和外部调用。

该框架的运行配置可以通过命令行参数传入，也可以通过位于 config/ 目录下的配置文件指定，--env 参数可以指定使用哪个配置文件，例如 --env=master 指定使用 master.ini。需要注意 master 需要指定监听的端口号，worker 需要指定监听端口号和 master 的 ip:port。

1.2 运行方法

方案一：Docker Compose（推荐）

确保docker-compose.yaml存在于您的项目根目录中。如果没有，以下是一个示例：

services:
  vermeer-master:
    image: hugegraph/vermeer
    container_name: vermeer-master
    volumes:
      - ~/.config:/go/bin/config # Change here to your actual config path
    command: --env=master
    networks:
      vermeer_network:
        ipv4_address: 172.20.0.10 # Assign a static IP for the master

  vermeer-worker:
    image: hugegraph/vermeer
    container_name: vermeer-worker
    volumes:
      - ~/:/go/bin/config # Change here to your actual config path
    command: --env=worker
    networks:
      vermeer_network:
        ipv4_address: 172.20.0.11 # Assign a static IP for the worker

networks:
  vermeer_network:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/24 # Define the subnet for your network

修改 docker-compose.yaml

Volume：例如将两处 ~/:/go/bin/config 改为 /home/user/config:/go/bin/config（或您自己的配置目录）。
Subnet：根据实际情况修改子网IP。请注意，每个容器需要访问的端口在config文件中指定，具体请参照项目config文件夹下内容。

在项目目录构建镜像并启动（或者先用 docker build 再 docker-compose up）

# 构建镜像（在项目根 vermeer 目录）
docker build -t hugegraph/vermeer .

# 启动（在 vermeer 根目录）
docker-compose up -d
# 或使用新版 CLI：
# docker compose up -d

查看日志 / 停止 / 删除：

docker-compose logs -f
docker-compose down

方案二：通过 docker run 单独启动（手动创建网络并分配静态 IP）

确保CONFIG_DIR对Docker进程具有适当的读取/执行权限。

构建镜像：

docker build -t hugegraph/vermeer .

创建自定义 bridge 网络（一次性操作）：

docker network create --driver bridge \
  --subnet 172.20.0.0/24 \
  vermeer_network

运行 master（调整 CONFIG_DIR 为您的绝对配置路径，可以根据实际情况调整IP）：

CONFIG_DIR=/home/user/config

docker run -d \
  --name vermeer-master \
  --network vermeer_network --ip 172.20.0.10 \
  -v ${CONFIG_DIR}:/go/bin/config \
  hugegraph/vermeer \
  --env=master

运行 worker：

docker run -d \
  --name vermeer-worker \
  --network vermeer_network --ip 172.20.0.11 \
  -v ${CONFIG_DIR}:/go/bin/config \
  hugegraph/vermeer \
  --env=worker

查看日志 / 停止 / 删除：

docker logs -f vermeer-master
docker logs -f vermeer-worker

docker stop vermeer-master vermeer-worker
docker rm vermeer-master vermeer-worker

# 删除自定义网络（如果需要）
docker network rm vermeer_network

方案三：从源码构建

构建。具体请参照 Vermeer Readme。

go build

在进入文件夹目录后输入 ./vermeer --env=master 或 ./vermeer --env=worker01

二、任务创建类 rest api

2.1 简介

此类 rest api 提供所有创建任务的功能，包括读取图数据和多种计算功能，提供异步返回和同步返回两种接口。返回的内容均包含所创建任务的信息。使用 vermeer 的整体流程是先创建读取图的任务，待图读取完毕后创建计算任务执行计算。图不会自动被删除，在一个图上运行多个计算任务无需多次重复读取，如需删除可用删除图接口。任务状态可分为读取任务状态和计算任务状态。通常情况下客户端仅需了解创建、任务中、任务结束和任务错误四种状态。图状态是图是否可用的判断依据，若图正在读取中或图状态错误，无法使用该图创建计算任务。图删除接口仅在 loaded 和 error 状态且该图无计算任务时可用。

可以使用的 url 如下：

异步返回接口 POST http://master_ip:port/tasks/create 仅返回任务创建是否成功，需通过主动查询任务状态判断是否完成。
同步返回接口 POST http://master_ip:port/tasks/create/sync 在任务结束后返回。

2.2 加载图数据

具体参数参考 Vermeer 参数列表文档。

vermeer提供三种加载方式：

从本地加载

可以预先获取数据集，例如 twitter-2010 数据集。获取方式：https://snap.stanford.edu/data/twitter-2010.html，第一个 twitter-2010.txt.gz 即可。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "load",
 "graph": "testdb",
 "params": {
  "load.parallel": "50",
  "load.type": "local",
  "load.vertex_files": "{\"localhost\":\"data/twitter-2010.v_[0,99]\"}",
  "load.edge_files": "{\"localhost\":\"data/twitter-2010.e_[0,99]\"}",
  "load.use_out_degree": "1",
  "load.use_outedge": "1"
 }
}

从hugegraph加载

request 示例：

⚠️ 安全警告：切勿在配置文件或代码中存储真实密码。请改用环境变量或安全的凭据管理系统。

POST http://localhost:8688/tasks/create
{
  "task_type": "load",
  "graph": "testdb",
  "params": {
    "load.parallel": "50",
    "load.type": "hugegraph",
    "load.hg_pd_peers": "[\"<your-hugegraph-ip>:8686\"]",
    "load.hugegraph_name": "DEFAULT/hugegraph2/g",
    "load.hugegraph_username": "admin",
    "load.hugegraph_password": "<your-password-here>",
    "load.use_out_degree": "1",
    "load.use_outedge": "1"
  }
}

从hdfs加载

request 示例：

POST http://localhost:8688/tasks/create
{
  "task_type": "load",
  "graph": "testdb",
  "params": {
    "load.parallel": "50",
    "load.type": "hdfs",
    "load.hdfs_namenode": "name_node1:9000",
    "load.hdfs_conf_path": "/path/to/conf",
    "load.krb_realm": "EXAMPLE.COM",
    "load.krb_name": "user@EXAMPLE.COM",
    "load.krb_keytab_path": "/path/to/keytab",
    "load.krb_conf_path": "/path/to/krb5.conf",
    "load.hdfs_use_krb": "1",
    "load.vertex_files": "/data/graph/vertices",
    "load.edge_files": "/data/graph/edges",
    "load.use_out_degree": "1",
    "load.use_outedge": "1"
  }
}

2.3 输出计算结果

所有的 vermeer 计算任务均支持多种结果输出方式，可自定义输出方式：local、hdfs、afs 或 hugegraph，在发送请求时的 params 参数下加入对应参数，即可生效。指定 output.need_statistics 为 1 时，支持计算结果统计信息输出，结果会写在接口任务信息内。统计模式算子目前支持 “count” 和 “modularity” 。但仅针对社区发现算法适用。

具体参数参考 Vermeer 参数列表文档。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "pagerank",
 "compute.parallel": "10",
 "compute.max_step": "10",
 "output.type": "local",
 "output.parallel": "1",
 "output.file_path": "result/pagerank"
  }
}

三、支持的算法

3.1 PageRank

PageRank 算法又称网页排名算法，是一种由搜索引擎根据网页（节点）之间相互的超链接进行计算的技

术，用来体现网页（节点）的相关性和重要性。

如果一个网页被很多其他网页链接到，说明这个网页比较重要，也就是其 PageRank 值会相对较高。
如果一个 PageRank 值很高的网页链接到其他网页，那么被链接到的网页的 PageRank 值会相应地提高。

PageRank 算法适用于网页排序、社交网络重点人物发掘等场景。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "pagerank",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/pagerank",
 "compute.max_step":"10"
 }
}

3.2 WCC（弱连通分量）

弱连通分量，计算无向图中所有联通的子图，输出各顶点所属的弱联通子图 id，表明各个点之间的连通性，区分不同的连通社区。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "wcc",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/wcc",
 "compute.max_step":"10"
 }
}

3.3 LPA（标签传播）

标签传递算法，是一种图聚类算法，常用在社交网络中，用于发现潜在的社区。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "lpa",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/lpa",
 "compute.max_step":"10"
 }
}

3.4 Degree Centrality（度中心性）

度中心性算法，算法用于计算图中每个节点的度中心性值，支持无向图和有向图。度中心性是衡量节点重要性的重要指标，节点与其它节点的边越多，则节点的度中心性值越大，节点在图中的重要性也就越高。在无向图中，度中心性的计算是基于边信息统计节点出现次数，得出节点的度中心性的值，在有向图中则基于边的方向进行筛选，基于输入边或输出边信息统计节点出现次数，得到节点的入度值或出度值。它表明各个点的重要性，一般越重要的点度数越高。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "degree",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/degree",
 "degree.direction":"both"
 }
}

3.5 Closeness Centrality（紧密中心性）

紧密中心性（Closeness Centrality）用于计算一个节点到所有其他可达节点的最短距离的倒数，进行累积后归一化的值。紧密中心度可以用来衡量信息从该节点传输到其他节点的时间长短。节点的“Closeness Centrality”越大，其在所在图中的位置越靠近中心，适用于社交网络中关键节点发掘等场景。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "closeness_centrality",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/closeness_centrality",
 "closeness_centrality.sample_rate":"0.01"
 }
}

3.6 Betweenness Centrality（中介中心性算法）

中介中心性算法（Betweeness Centrality）判断一个节点具有"桥梁"节点的值，值越大说明它作为图中两点间必经路径的可能性越大，典型的例子包括社交网络中的共同关注的人。适用于衡量社群围绕某个节点的聚集程度。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "betweenness_centrality",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/betweenness_centrality",
 "betweenness_centrality.sample_rate":"0.01"
 }
}

3.7 Triangle Count（三角形计数）

三角形计数算法，用于计算通过每个顶点的三角形个数，适用于计算用户之间的关系，关联性是不是成三角形。三角形越多，代表图中节点关联程度越高，组织关系越严密。社交网络中的三角形表示存在有凝聚力的社区，识别三角形有助于理解网络中个人或群体的聚类和相互联系。在金融网络或交易网络中，三角形的存在可能表示存在可疑或欺诈活动，三角形计数可以帮助识别可能需要进一步调查的交易模式。

输出的结果为每个顶点对应一个 Triangle Count，即为每个顶点所在三角形的个数。

注：该算法为无向图算法，忽略边的方向。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "triangle_count",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/triangle_count"
 }
}

3.8 K-Core

K-Core 算法，标记所有度数为 K 的顶点，适用于图的剪枝，查找图的核心部分。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "kcore",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/kcore",
 "kcore.degree_k":"5"
 }
}

3.9 SSSP（单元最短路径）

单源最短路径算法，求一个点到其他所有点的最短距离。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "sssp",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/degree",
 "sssp.source":"tom"
 }
}

3.10 KOUT

以一个点为起点，获取这个点的 k 层的节点。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "kout",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/kout",
 "kout.source":"tom",
 "compute.max_step":"6"
 }
}

3.11 Louvain

Louvain 算法是一种基于模块度的社区发现算法。其基本思想是网络中节点尝试遍历所有邻居的社区标签，并选择最大化模块度增量的社区标签。在最大化模块度之后，每个社区看成一个新的节点，重复直到模块度不再增大。

Vermeer 上实现的分布式 Louvain 算法受节点顺序、并行计算等因素影响，并且由于 Louvain 算法由于其遍历顺序的随机导致社区压缩也具有一定的随机性，导致重复多次执行可能存在不同的结果。但整体趋势不会有大的变化。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "louvain",
 "compute.parallel":"10",
 "compute.max_step":"1000",
 "louvain.threshold":"0.0000001",
 "louvain.resolution":"1.0",
 "louvain.step":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/louvain"
  }
 }

3.12 Jaccard 相似度系数

Jaccard index , 又称为 Jaccard 相似系数（Jaccard similarity coefficient）用于比较有限样本集之间的相似性与差异性。Jaccard 系数值越大，样本相似度越高。用于计算一个给定的源点，与图中其他所有点的 Jaccard 相似系数。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "jaccard",
 "compute.parallel":"10",
 "compute.max_step":"2",
 "jaccard.source":"123",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/jaccard"
 }
}

3.13 Personalized PageRank

个性化的 pagerank 的目标是要计算所有节点相对于用户 u 的相关度。从用户 u 对应的节点开始游走，每到一个节点都以 1-d 的概率停止游走并从 u 重新开始，或者以 d 的概率继续游走，从当前节点指向的节点中按照均匀分布随机选择一个节点往下游走。用于给定一个起点，计算此起点开始游走的个性化 pagerank 得分。适用于社交推荐等场景。

由于计算需要使用出度，需要在读取图时需要设置 load.use_out_degree 为 1。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "ppr",
 "compute.parallel":"100",
 "compute.max_step":"10",
 "ppr.source":"123",
 "ppr.damping":"0.85",
 "ppr.diff_threshold":"0.00001",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/ppr"
 }
}

3.14 全图 Kout

计算图的所有节点的k度邻居（不包含自己以及1～k-1度的邻居），由于全图kout算法内存膨胀比较厉害，目前k限制在1和2，另外，全局kout算法支持过滤功能( 参数如：“compute.filter”:“risk_level==1”),在计算第k度的是时候进行过滤条件的判断，符合过滤条件的进入最终结果集，算法最终输出是符合条件的邻居个数。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "kout_all",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"10",
 "output.file_path":"result/kout",
 "compute.max_step":"2"，
 "compute.filter":"risk_level==1"
 }
}

3.15 集聚系数 clustering coefficient

集聚系数表示一个图中节点聚集程度的系数。在现实的网络中，尤其是在特定的网络中，由于相对高密度连接点的关系，节点总是趋向于建立一组严密的组织关系。集聚系数算法（Cluster Coefficient）用于计算图中节点的聚集程度。本算法为局部集聚系数。局部集聚系数可以测量图中每一个结点附近的集聚程度。

request 示例：

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "clustering_coefficient",
 "compute.parallel":"100",
 "compute.max_step":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/cc"
 }
}

3.16 SCC（强连通分量）

在有向图的数学理论中，如果一个图的每一个顶点都可从该图其他任意一点到达，则称该图是强连通的。在任意有向图中能够实现强连通的部分我们称其为强连通分量。它表明各个点之间的连通性，区分不同的连通社区。

POST http://localhost:8688/tasks/create
{
 "task_type": "compute",
 "graph": "testdb",
 "params": {
 "compute.algorithm": "scc",
 "compute.parallel":"10",
 "output.type":"local",
 "output.parallel":"1",
 "output.file_path":"result/scc",
 "compute.max_step":"200"
 }
}

🚧, 后续随时更新完善，欢迎随时提出建议和意见。

2 - HugeGraph-Computer Quick Start

1 HugeGraph-Computer 概述

HugeGraph-Computer 是分布式图处理系统 (OLAP). 它是 Pregel的一个实现。它可以运行在 Kubernetes(K8s)/Yarn 上。(它侧重可支持百亿~千亿的图数据量下进行图计算, 会使用磁盘进行排序和加速, 这是它和 Vermeer 相对最大的区别之一)

特性

支持分布式 MPP 图计算，集成 HugeGraph 作为图输入输出存储。
算法基于 BSP(Bulk Synchronous Parallel) 模型，通过多次并行迭代进行计算，每一次迭代都是一次超步。
自动内存管理。该框架永远不会出现 OOM（内存不足），因为如果它没有足够的内存来容纳所有数据，它会将一些数据拆分到磁盘。
边的部分或超级节点的消息可以在内存中，所以你永远不会丢失它。
您可以从 HDFS 或 HugeGraph 或任何其他系统加载数据。
您可以将结果输出到 HDFS 或 HugeGraph，或任何其他系统。
易于开发新算法。您只需要像在单个服务器中一样专注于仅顶点处理，而不必担心消息传输和内存存储管理。

2 依赖

2.1 安装 Java 11 (JDK 11)

必须在 ≥ Java 11 的环境上启动 Computer，然后自行配置。

在往下阅读之前务必执行 java -version 命令查看 jdk 版本

3 开始

3.1 在本地运行 PageRank 算法

要使用 HugeGraph-Computer 运行算法，必须装有 Java 11 或更高版本。
还需要首先部署 HugeGraph-Server 和 Etcd.

有两种方式可以获取 HugeGraph-Computer：

下载已编译的压缩包
克隆源码编译打包

3.1.1 下载已编译的压缩包

下载最新版本的 HugeGraph-Computer release 包：

wget https://downloads.apache.org/incubator/hugegraph/${version}/apache-hugegraph-computer-incubating-${version}.tar.gz
tar zxvf apache-hugegraph-computer-incubating-${version}.tar.gz -C hugegraph-computer

3.1.2 克隆源码编译打包

克隆最新版本的 HugeGraph-Computer 源码包：

$ git clone https://github.com/apache/hugegraph-computer.git

编译生成 tar 包：

cd hugegraph-computer
mvn clean package -DskipTests

3.1.3 启动 master 节点

您可以使用 -c 参数指定配置文件，更多 computer 配置请看：Computer Config Options

cd hugegraph-computer
bin/start-computer.sh -d local -r master

3.1.4 启动 worker 节点

bin/start-computer.sh -d local -r worker

3.1.5 查询算法结果

2.5.1 为 server 启用 OLAP 索引查询

如果没有启用 OLAP 索引，则需要启用，更多参考：modify-graphs-read-mode

PUT http://localhost:8080/graphs/hugegraph/graph_read_mode

"ALL"

3.1.5.2 查询 page_rank 属性值：

curl "http://localhost:8080/graphs/hugegraph/graph/vertices?page&limit=3" | gunzip

3.2 在 Kubernetes 中运行 PageRank 算法

要使用 HugeGraph-Computer 运行算法，您需要先部署 HugeGraph-Server

3.2.1 安装 HugeGraph-Computer CRD

# Kubernetes version >= v1.16
kubectl apply -f https://raw.githubusercontent.com/apache/hugegraph-computer/master/computer-k8s-operator/manifest/hugegraph-computer-crd.v1.yaml

# Kubernetes version < v1.16
kubectl apply -f https://raw.githubusercontent.com/apache/hugegraph-computer/master/computer-k8s-operator/manifest/hugegraph-computer-crd.v1beta1.yaml

3.2.2 显示 CRD

kubectl get crd

NAME                                        CREATED AT
hugegraphcomputerjobs.hugegraph.apache.org   2021-09-16T08:01:08Z

3.2.3 安装 hugegraph-computer-operator&etcd-server

kubectl apply -f https://raw.githubusercontent.com/apache/hugegraph-computer/master/computer-k8s-operator/manifest/hugegraph-computer-operator.yaml

3.2.4 等待 hugegraph-computer-operator&etcd-server 部署完成

kubectl get pod -n hugegraph-computer-operator-system

NAME                                                              READY   STATUS    RESTARTS   AGE
hugegraph-computer-operator-controller-manager-58c5545949-jqvzl   1/1     Running   0          15h
hugegraph-computer-operator-etcd-28lm67jxk5                       1/1     Running   0          15h

3.2.5 提交作业

更多 computer crd spec 请看：Computer CRD
更多 Computer 配置请看：Computer Config Options

cat <<EOF | kubectl apply --filename -
apiVersion: hugegraph.apache.org/v1
kind: HugeGraphComputerJob
metadata:
  namespace: hugegraph-computer-operator-system
  name: &jobName pagerank-sample
spec:
  jobId: *jobName
  algorithmName: page_rank
  image: hugegraph/hugegraph-computer:latest # algorithm image url
  jarFile: /hugegraph/hugegraph-computer/algorithm/builtin-algorithm.jar # algorithm jar path
  pullPolicy: Always
  workerCpu: "4"
  workerMemory: "4Gi"
  workerInstances: 5
  computerConf:
    job.partitions_count: "20"
    algorithm.params_class: org.apache.hugegraph.computer.algorithm.centrality.pagerank.PageRankParams
    hugegraph.url: http://${hugegraph-server-host}:${hugegraph-server-port} # hugegraph server url
    hugegraph.name: hugegraph # hugegraph graph name
EOF

3.2.6 显示作业

kubectl get hcjob/pagerank-sample -n hugegraph-computer-operator-system

NAME               JOBID              JOBSTATUS
pagerank-sample    pagerank-sample    RUNNING

3.2.7 显示节点日志

# Show the master log
kubectl logs -l component=pagerank-sample-master -n hugegraph-computer-operator-system

# Show the worker log
kubectl logs -l component=pagerank-sample-worker -n hugegraph-computer-operator-system

# Show diagnostic log of a job
# 注意: 诊断日志仅在作业失败时存在，并且只会保存一小时。
kubectl get event --field-selector reason=ComputerJobFailed --field-selector involvedObject.name=pagerank-sample -n hugegraph-computer-operator-system

3.2.8 显示作业的成功事件

NOTE: it will only be saved for one hour

kubectl get event --field-selector reason=ComputerJobSucceed --field-selector involvedObject.name=pagerank-sample -n hugegraph-computer-operator-system

3.2.9 查询算法结果

如果输出到 Hugegraph-Server 则与 Locally 模式一致，如果输出到 HDFS ，请检查 hugegraph-computerresults{jobId}目录下的结果文件。

4 内置算法文档

4.1 支持的算法列表：

中心性算法：

PageRank
BetweennessCentrality
ClosenessCentrality
DegreeCentrality

社区算法：

ClusteringCoefficient
Kcore
Lpa
TriangleCount
Wcc

路径算法：

RingsDetection
RingsDetectionWithFilter

更多算法请看：Built-In algorithms

4.2 算法描述

TODO

5 算法开发指南

TODO

6 注意事项

如果 computer-k8s 模块下面的某些类不存在，你需要运行mvn compile来提前生成对应的类。

3 - HugeGraph-Computer 配置参考

Computer 配置选项

默认值说明:
以下配置项显示的是代码默认值(定义在 ComputerOptions.java 中)
当打包配置文件(conf/computer.properties 分发包中)指定了不同的值时,会以 值 (打包: 值) 的形式标注
示例:300000 (打包: 100000) 表示代码默认值为 300000,但分发包默认值为 100000
对于生产环境部署,除非明确覆盖,否则打包默认值优先生效

1. 基础配置

HugeGraph-Computer 核心作业设置。

配置项	默认值	说明
hugegraph.url	http://127.0.0.1:8080	HugeGraph 服务器 URL,用于加载数据和写回结果。
hugegraph.name	hugegraph	图名称,用于加载数据和写回结果。
hugegraph.username	"" (空)	HugeGraph 认证用户名(如果未启用认证则留空)。
hugegraph.password	"" (空)	HugeGraph 认证密码(如果未启用认证则留空)。
job.id	local_0001 (打包: local_001)	YARN 集群或 K8s 集群上的作业标识符。
job.namespace	"" (空)	作业命名空间,可以分隔不同的数据源。🔒 由系统管理 - 不要手动修改。
job.workers_count	1	执行一个图算法作业的 Worker 数量。🔒 在 K8s 中由系统管理 - 不要手动修改。
job.partitions_count	1	执行一个图算法作业的分区数量。
job.partitions_thread_nums	4	分区并行计算的线程数量。

2. 算法配置

计算逻辑的算法特定配置。

配置项	默认值	说明
algorithm.params_class	org.apache.hugegraph.computer.core.config.Null	⚠️ 必填在算法运行前用于传递算法参数的类。
algorithm.result_class	org.apache.hugegraph.computer.core.config.Null	顶点值的类,用于存储顶点的计算结果。
algorithm.message_class	org.apache.hugegraph.computer.core.config.Null	计算顶点时传递的消息类。

3. 输入配置

从 HugeGraph 或其他数据源加载输入数据的配置。

3.1 输入源

配置项	默认值	说明
input.source_type	hugegraph-server	加载输入数据的源类型,允许值:[‘hugegraph-server’, ‘hugegraph-loader’]。‘hugegraph-loader’ 表示使用 hugegraph-loader 从 HDFS 或文件加载数据。如果使用 ‘hugegraph-loader’,请配置 ‘input.loader_struct_path’ 和 ‘input.loader_schema_path’。
input.loader_struct_path	"" (空)	Loader 输入的结构路径,仅在 input.source_type=loader 启用时生效。
input.loader_schema_path	"" (空)	Loader 输入的 schema 路径,仅在 input.source_type=loader 启用时生效。

3.2 输入分片

配置项	默认值	说明
input.split_size	1048576 (1 MB)	输入分片大小(字节)。
input.split_max_splits	10000000	最大输入分片数量。
input.split_page_size	500	流式加载输入分片数据的页面大小。
input.split_fetch_timeout	300	获取输入分片的超时时间(秒)。

3.3 输入处理

配置项	默认值	说明
input.filter_class	org.apache.hugegraph.computer.core.input.filter.DefaultInputFilter	创建输入过滤器对象的类。输入过滤器用于根据用户需求过滤顶点边。
input.edge_direction	OUT	要加载的边的方向,允许值:[OUT, IN, BOTH]。当值为 BOTH 时,将加载 OUT 和 IN 两个方向的边。
input.edge_freq	MULTIPLE	一对顶点之间可以存在的边的频率,允许值:[SINGLE, SINGLE_PER_LABEL, MULTIPLE]。SINGLE 表示一对顶点之间只能存在一条边(通过 sourceId + targetId 标识);SINGLE_PER_LABEL 表示每个边标签在一对顶点之间可以有一条边(通过 sourceId + edgeLabel + targetId 标识);MULTIPLE 表示一对顶点之间可以存在多条边(通过 sourceId + edgeLabel + sortValues + targetId 标识)。
input.max_edges_in_one_vertex	200	允许附加到一个顶点的最大邻接边数量。邻接边将作为一个批处理单元一起存储和传输。

3.4 输入性能

配置项	默认值	说明
input.send_thread_nums	4	并行发送顶点或边的线程数量。

4. 快照与存储配置

HugeGraph-Computer 支持快照功能,可将顶点/边分区保存到本地存储或 MinIO 对象存储,用于断点恢复或加速重复计算。

4.1 基础快照配置

配置项	默认值	说明
snapshot.write	false	是否写入输入顶点/边分区的快照。
snapshot.load	false	是否从顶点/边分区的快照加载。
snapshot.name	"" (空)	用户自定义的快照名称,用于区分不同的快照。

4.2 MinIO 集成(可选)

MinIO 可用作 K8s 部署中快照的分布式对象存储后端。

配置项	默认值	说明
snapshot.minio_endpoint	"" (空)	MinIO 服务端点(例如 `http://minio:9000`)。使用 MinIO 时必填。
snapshot.minio_access_key	minioadmin	MinIO 认证访问密钥。
snapshot.minio_secret_key	minioadmin	MinIO 认证密钥。
snapshot.minio_bucket_name	"" (空)	用于存储快照数据的 MinIO 存储桶名称。

使用场景:

断点恢复:作业失败后从快照恢复,避免重新加载数据
重复计算:多次运行同一算法时从快照加载数据以加速启动
A/B 测试:保存同一数据集的多个快照版本,测试不同的算法参数

示例:本地快照(在 computer.properties 中):

snapshot.write=true
snapshot.name=pagerank-snapshot-20260201

示例:MinIO 快照(在 K8s CRD computerConf 中):

computerConf:
  snapshot.write: "true"
  snapshot.name: "pagerank-snapshot-v1"
  snapshot.minio_endpoint: "http://minio:9000"
  snapshot.minio_access_key: "my-access-key"
  snapshot.minio_secret_key: "my-secret-key"
  snapshot.minio_bucket_name: "hugegraph-snapshots"

5. Worker 与 Master 配置

Worker 和 Master 计算逻辑的配置。

5.1 Master 配置

配置项	默认值	说明
master.computation_class	org.apache.hugegraph.computer.core.master.DefaultMasterComputation	Master 计算是可以决定是否继续下一个超步的计算。它在每个超步结束时在 master 上运行。

5.2 Worker 计算

配置项	默认值	说明
worker.computation_class	org.apache.hugegraph.computer.core.config.Null	创建 worker 计算对象的类。Worker 计算用于在每个超步中计算每个顶点。
worker.combiner_class	org.apache.hugegraph.computer.core.config.Null	Combiner 可以将消息组合为一个顶点的一个值。例如,PageRank 算法可以将一个顶点的消息组合为一个求和值。
worker.partitioner	org.apache.hugegraph.computer.core.graph.partition.HashPartitioner	分区器,决定顶点应该在哪个分区中,以及分区应该在哪个 worker 中。

5.3 Worker 组合器

配置项	默认值	说明
worker.vertex_properties_combiner_class	org.apache.hugegraph.computer.core.combiner.OverwritePropertiesCombiner	组合器可以在输入步骤将同一顶点的多个属性组合为一个属性。
worker.edge_properties_combiner_class	org.apache.hugegraph.computer.core.combiner.OverwritePropertiesCombiner	组合器可以在输入步骤将同一边的多个属性组合为一个属性。

5.4 Worker 缓冲区

配置项	默认值	说明
worker.received_buffers_bytes_limit	104857600 (100 MB)	接收数据缓冲区的限制字节数。所有缓冲区的总大小不能超过此限制。如果接收缓冲区达到此限制,它们将被合并到文件中(溢出到磁盘)。
worker.write_buffer_capacity	52428800 (50 MB)	用于存储顶点或消息的写缓冲区的初始大小。
worker.write_buffer_threshold	52428800 (50 MB)	写缓冲区的阈值。超过它将触发排序。写缓冲区用于存储顶点或消息。

5.5 Worker 数据与超时

配置项	默认值	说明
worker.data_dirs	[jobs]	用逗号分隔的目录,接收的顶点和消息可以持久化到其中。
worker.wait_sort_timeout	600000 (10 分钟)	消息处理程序等待排序线程对一批缓冲区进行排序的最大超时时间(毫秒)。
worker.wait_finish_messages_timeout	86400000 (24 小时)	消息处理程序等待所有 worker 完成消息的最大超时时间(毫秒)。

6. I/O 与输出配置

输出计算结果的配置。

6.1 输出类与结果

配置项	默认值	说明
output.output_class	org.apache.hugegraph.computer.core.output.LogOutput	输出每个顶点计算结果的类。在迭代计算后调用。
output.result_name	value	该值由 WORKER_COMPUTATION_CLASS 创建的实例的 #name() 动态分配。
output.result_write_type	OLAP_COMMON	输出到 HugeGraph 的结果写入类型,允许值:[OLAP_COMMON, OLAP_SECONDARY, OLAP_RANGE]。

6.2 输出行为

配置项	默认值	说明
output.with_adjacent_edges	false	是否输出顶点的邻接边。
output.with_vertex_properties	false	是否输出顶点的属性。
output.with_edge_properties	false	是否输出边的属性。

6.3 批量输出

配置项	默认值	说明
output.batch_size	500	输出的批处理大小。
output.batch_threads	1	用于批量输出的线程数量。
output.single_threads	1	用于单个输出的线程数量。

6.4 HDFS 输出

配置项	默认值	说明
output.hdfs_url	hdfs://127.0.0.1:9000	输出的 HDFS URL。
output.hdfs_user	hadoop	输出的 HDFS 用户。
output.hdfs_path_prefix	/hugegraph-computer/results	HDFS 输出结果的目录。
output.hdfs_delimiter	, (逗号)	HDFS 输出的分隔符。
output.hdfs_merge_partitions	true	是否合并多个分区的输出文件。
output.hdfs_replication	3	HDFS 的副本数。
output.hdfs_core_site_path	"" (空)	HDFS core site 路径。
output.hdfs_site_path	"" (空)	HDFS site 路径。
output.hdfs_kerberos_enable	false	是否为 HDFS 启用 Kerberos 认证。
output.hdfs_kerberos_principal	"" (空)	HDFS 的 Kerberos 认证 principal。
output.hdfs_kerberos_keytab	"" (空)	HDFS 的 Kerberos 认证 keytab 文件。
output.hdfs_krb5_conf	/etc/krb5.conf	Kerberos 配置文件路径。

6.5 重试与超时

配置项	默认值	说明
output.retry_times	3	输出失败时的重试次数。
output.retry_interval	10	输出失败时的重试间隔(秒)。
output.thread_pool_shutdown_timeout	60	输出线程池关闭的超时时间(秒)。

7. 网络与传输配置

Worker 和 Master 之间网络通信的配置。

7.1 服务器配置

配置项	默认值	说明
transport.server_host	127.0.0.1	🔒 由系统管理监听传输数据的服务器主机名或 IP。不要手动修改。
transport.server_port	0	🔒 由系统管理监听传输数据的服务器端口。如果设置为 0,系统将分配一个随机端口。不要手动修改。
transport.server_threads	4	服务器传输线程的数量。

7.2 客户端配置

配置项	默认值	说明
transport.client_threads	4	客户端传输线程的数量。
transport.client_connect_timeout	3000	客户端连接到服务器的超时时间(毫秒)。

7.3 协议配置

配置项	默认值	说明
transport.provider_class	org.apache.hugegraph.computer.core.network.netty.NettyTransportProvider	传输提供程序,目前仅支持 Netty。
transport.io_mode	AUTO	网络 IO 模式,允许值:[NIO, EPOLL, AUTO]。AUTO 表示自动选择适当的模式。
transport.tcp_keep_alive	true	是否启用 TCP keep-alive。
transport.transport_epoll_lt	false	是否启用 EPOLL 水平触发(仅在 io_mode=EPOLL 时有效)。

7.4 缓冲区配置

配置项	默认值	说明
transport.send_buffer_size	0	Socket 发送缓冲区大小(字节)。0 表示使用系统默认值。
transport.receive_buffer_size	0	Socket 接收缓冲区大小(字节)。0 表示使用系统默认值。
transport.write_buffer_high_mark	67108864 (64 MB)	写缓冲区的高水位标记(字节)。如果排队字节数 > write_buffer_high_mark,将触发发送不可用。
transport.write_buffer_low_mark	33554432 (32 MB)	写缓冲区的低水位标记(字节)。如果排队字节数 < write_buffer_low_mark,将触发发送可用。

7.5 流量控制

配置项	默认值	说明
transport.max_pending_requests	8	客户端未接收 ACK 的最大数量。如果未接收 ACK 的数量 >= max_pending_requests,将触发发送不可用。
transport.min_pending_requests	6	客户端未接收 ACK 的最小数量。如果未接收 ACK 的数量 < min_pending_requests,将触发发送可用。
transport.min_ack_interval	200	服务器回复 ACK 的最小间隔(毫秒)。

7.6 超时配置

配置项	默认值	说明
transport.close_timeout	10000	关闭服务器或关闭客户端的超时时间(毫秒)。
transport.sync_request_timeout	10000	发送同步请求后等待响应的超时时间(毫秒)。
transport.finish_session_timeout	0	完成会话的超时时间(毫秒)。0 表示使用 (transport.sync_request_timeout × transport.max_pending_requests)。
transport.write_socket_timeout	3000	将数据写入 socket 缓冲区的超时时间(毫秒)。
transport.server_idle_timeout	360000 (6 分钟)	服务器空闲的最大超时时间(毫秒)。

7.7 心跳配置

配置项	默认值	说明
transport.heartbeat_interval	20000 (20 秒)	客户端心跳之间的最小间隔(毫秒)。
transport.max_timeout_heartbeat_count	120	客户端超时心跳的最大次数。如果连续等待心跳响应超时的次数 > max_timeout_heartbeat_count,通道将从客户端关闭。

7.8 高级网络设置

配置项	默认值	说明
transport.max_syn_backlog	511	服务器端 SYN 队列的容量。0 表示使用系统默认值。
transport.recv_file_mode	true	是否启用接收缓冲文件模式。如果启用,将使用零拷贝从 socket 接收缓冲区并写入文件。注意:需要操作系统支持零拷贝(例如 Linux sendfile/splice)。
transport.network_retries	3	网络通信不稳定时的重试次数。

8. 存储与持久化配置

HGKV(HugeGraph Key-Value)存储引擎和值文件的配置。

8.1 HGKV 配置

配置项	默认值	说明
hgkv.max_file_size	2147483648 (2 GB)	每个 HGKV 文件的最大字节数。
hgkv.max_data_block_size	65536 (64 KB)	HGKV 文件数据块的最大字节大小。
hgkv.max_merge_files	10	一次合并的最大文件数。
hgkv.temp_file_dir	/tmp/hgkv	此文件夹用于在文件合并过程中存储临时文件。

8.2 值文件配置

配置项	默认值	说明
valuefile.max_segment_size	1073741824 (1 GB)	值文件每个段的最大字节数。

9. BSP 与协调配置

批量同步并行(BSP)协议和 etcd 协调的配置。

配置项	默认值	说明
bsp.etcd_endpoints	http://localhost:2379	🔒 在 K8s 中由系统管理访问 etcd 的端点。对于多个端点,使用逗号分隔列表:`http://host1:port1,http://host2:port2`。不要在 K8s 部署中手动修改。
bsp.max_super_step	10 (打包: 2)	算法的最大超步数。
bsp.register_timeout	300000 (打包: 100000)	等待 master 和 worker 注册的最大超时时间(毫秒)。
bsp.wait_workers_timeout	86400000 (24 小时)	等待 worker BSP 事件的最大超时时间(毫秒)。
bsp.wait_master_timeout	86400000 (24 小时)	等待 master BSP 事件的最大超时时间(毫秒)。
bsp.log_interval	30000 (30 秒)	等待 BSP 事件时打印日志的日志间隔(毫秒)。

10. 性能调优配置

性能优化的配置。

配置项	默认值	说明
allocator.max_vertices_per_thread	10000	每个内存分配器中每个线程处理的最大顶点数。
sort.thread_nums	4	执行内部排序的线程数量。

11. 系统管理配置

⚠️ 由系统管理的配置项 - 禁止用户手动修改。

以下配置项由 K8s Operator、Driver 或运行时系统自动管理。手动修改将导致集群通信失败或作业调度错误。

配置项	管理者	说明
bsp.etcd_endpoints	K8s Operator	自动设置为 operator 的 etcd 服务地址
transport.server_host	运行时	自动设置为 pod/容器主机名
transport.server_port	运行时	自动分配随机端口
job.namespace	K8s Operator	自动设置为作业命名空间
job.id	K8s Operator	自动从 CRD 设置为作业 ID
job.workers_count	K8s Operator	自动从 CRD `workerInstances` 设置
rpc.server_host	运行时	RPC 服务器主机名(系统管理)
rpc.server_port	运行时	RPC 服务器端口(系统管理)
rpc.remote_url	运行时	RPC 远程 URL(系统管理)

为什么禁止修改:

BSP/RPC 配置:必须与实际部署的 etcd/RPC 服务匹配。手动覆盖会破坏协调。
作业配置:必须与 K8s CRD 规范匹配。不匹配会导致 worker 数量错误。
传输配置:必须使用实际的 pod 主机名/端口。手动值会阻止 worker 间通信。

K8s Operator 配置选项

注意:选项需要通过环境变量设置进行转换,例如 k8s.internal_etcd_url => INTERNAL_ETCD_URL

配置项	默认值	说明
k8s.auto_destroy_pod	true	作业完成或失败时是否自动销毁所有 pod。
k8s.close_reconciler_timeout	120	关闭 reconciler 的最大超时时间(毫秒)。
k8s.internal_etcd_url	http://127.0.0.1:2379	operator 系统的内部 etcd URL。
k8s.max_reconcile_retry	3	reconcile 的最大重试次数。
k8s.probe_backlog	50	服务健康探针的最大积压。
k8s.probe_port	9892	controller 绑定的用于服务健康探针的端口。
k8s.ready_check_internal	1000	检查就绪的时间间隔(毫秒)。
k8s.ready_timeout	30000	检查就绪的最大超时时间(毫秒)。
k8s.reconciler_count	10	reconciler 线程的最大数量。
k8s.resync_period	600000	被监视资源进行 reconcile 的最小频率。
k8s.timezone	Asia/Shanghai	computer 作业和 operator 的时区。
k8s.watch_namespace	hugegraph-computer-system	监视自定义资源的命名空间。使用 ‘*’ 监视所有命名空间。

HugeGraph-Computer CRD

CRD: https://github.com/apache/hugegraph-computer/blob/master/computer-k8s-operator/manifest/hugegraph-computer-crd.v1.yaml

字段	默认值	说明	必填
algorithmName		算法名称。	true
jobId		作业 ID。	true
image		算法镜像。	true
computerConf		computer 配置选项的映射。	true
workerInstances		worker 实例数量,将覆盖 ‘job.workers_count’ 选项。	true
pullPolicy	Always	镜像拉取策略,详情请参考:https://kubernetes.io/docs/concepts/containers/images/#image-pull-policy	false
pullSecrets		镜像拉取密钥,详情请参考:https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod	false
masterCpu		master 的 CPU 限制,单位可以是 ’m’ 或无单位,详情请参考:https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu	false
workerCpu		worker 的 CPU 限制,单位可以是 ’m’ 或无单位,详情请参考:https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu	false
masterMemory		master 的内存限制,单位可以是 Ei、Pi、Ti、Gi、Mi、Ki 之一,详情请参考:https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory	false
workerMemory		worker 的内存限制,单位可以是 Ei、Pi、Ti、Gi、Mi、Ki 之一,详情请参考:https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory	false
log4jXml		computer 作业的 log4j.xml 内容。	false
jarFile		computer 算法的 jar 路径。	false
remoteJarUri		computer 算法的远程 jar URI,将覆盖算法镜像。	false
jvmOptions		computer 作业的 Java 启动参数。	false
envVars		请参考:https://kubernetes.io/docs/tasks/inject-data-application/define-interdependent-environment-variables/	false
envFrom		请参考:https://kubernetes.io/docs/tasks/inject-data-application/define-environment-variable-container/	false
masterCommand	bin/start-computer.sh	master 的运行命令,等同于 Docker 的 ‘Entrypoint’ 字段。	false
masterArgs	["-r master", “-d k8s”]	master 的运行参数,等同于 Docker 的 ‘Cmd’ 字段。	false
workerCommand	bin/start-computer.sh	worker 的运行命令,等同于 Docker 的 ‘Entrypoint’ 字段。	false
workerArgs	["-r worker", “-d k8s”]	worker 的运行参数,等同于 Docker 的 ‘Cmd’ 字段。	false
volumes		请参考:https://kubernetes.io/docs/concepts/storage/volumes/	false
volumeMounts		请参考:https://kubernetes.io/docs/concepts/storage/volumes/	false
secretPaths		k8s-secret 名称和挂载路径的映射。	false
configMapPaths		k8s-configmap 名称和挂载路径的映射。	false
podTemplateSpec		请参考:https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-template-v1/#PodTemplateSpec	false
securityContext		请参考:https://kubernetes.io/docs/tasks/configure-pod-container/security-context/	false

KubeDriver 配置选项

配置项	默认值	说明
k8s.build_image_bash_path		用于构建镜像的命令路径。
k8s.enable_internal_algorithm	true	是否启用内部算法。
k8s.framework_image_url	hugegraph/hugegraph-computer:latest	computer 框架的镜像 URL。
k8s.image_repository_password		登录镜像仓库的密码。
k8s.image_repository_registry		登录镜像仓库的地址。
k8s.image_repository_url	hugegraph/hugegraph-computer	镜像仓库的 URL。
k8s.image_repository_username		登录镜像仓库的用户名。
k8s.internal_algorithm	[pageRank]	所有内部算法的名称列表。注意:算法名称在这里使用驼峰命名法(例如 `pageRank`),但算法实现返回下划线命名法(例如 `page_rank`)。
k8s.internal_algorithm_image_url	hugegraph/hugegraph-computer:latest	内部算法的镜像 URL。
k8s.jar_file_dir	/cache/jars/	算法 jar 将上传到的目录。
k8s.kube_config	~/.kube/config	k8s 配置文件的路径。
k8s.log4j_xml_path		computer 作业的 log4j.xml 路径。
k8s.namespace	hugegraph-computer-system	hugegraph-computer 系统的命名空间。
k8s.pull_secret_names	[]	拉取镜像的 pull-secret 名称。