设置您的链

主机（硬件提供商 或节点）向网络提供计算资源，并根据其提供的资源数量和质量获得奖励。

要加入网络，您需要部署两个服务：

网络节点 – 由两个节点组成的服务：一个链节点和一个API节点。此服务处理所有通信。链节点连接到区块链，而API节点管理用户请求。
推理（ML）节点 – 一种在GPU上执行大语言模型（LLM）推理的服务。您至少需要一个ML节点才能加入网络。

本指南描述了将两个服务部署在同一台机器上的场景，每个主机拥有一个ML节点。服务以Docker容器形式部署。

实时演示 — 如何启动节点（主机快速入门）

通过快速入门启动节点的演示会话录像如下。录像中的某些步骤可能与下方说明不同，因为快速入门会根据社区反馈持续更新。请始终遵循书面快速入门 —— 它反映了当前正确的流程。

先决条件

本节提供有关配置硬件基础设施以参与Gonka网络启动的指导。目标是通过使您的部署符合网络预期来最大化协议奖励。

支持的模型

该协议支持治理批准的模型用于推理和Proof of Compute（PoC v2）。在Gonka主网上，每个批准的模型都有其独立的PoC组和奖励追踪（自v0.2.12升级以来为多模型PoC）。

模型ID	角色
`MiniMaxAI/MiniMax-M2.7`	MiniMax M2.7 — 基础模型（自提案78 / 轮次308起）
`deepseek-ai/DeepSeek-V4-Flash-0731`	DeepSeek V4 Flash — PoC模型（自提案94 / 轮次360起）。系数位于`poc_params`。
`zai-org/GLM-5.3-Flash`	GLM-5.3-Flash — 自轮次395起为活跃PoC模型（提案101）。`penalty_start_epoch` 394。系数0.62位于`poc_params`。

权威模型列表（治理API）

批准的模型可能在版本或轮次之间发生变化。在您编辑node-config.json之前，调用治理API，并将每个返回对象的"id"作为"models"下的键：

curl -sS http://node2.gonka.ai:8000/v1/governance/models

要仅列出模型ID，请管道响应：jq -r '.models[].id'。如果node2.gonka.ai无法访问，请使用其他参与者的公共API基础URL（协议、主机和端口）。响应还包括网络参数，例如model_args；后面的node-config.json示例展示了常见硬件的典型args——请根据您的GPU和基准测试进行调整。

您通常在node-config.json中为每个ML节点运行一个模型。

治理列表（GET /v1/governance/models，poc_params.models）是每个模型的批准目录。模型的weight_scale_factor只有在该组有资格时才会产生共识权重：满足v_min和w_threshold的投票权。仅对有资格的组适用常规的错过/拒绝惩罚。无投票权的已列模型是下一个PoC的引导候选者——仅切换node-config无法恢复共识权重。请检查poc_params和该轮次的confirmation_weight_scales。参见多模型PoC。

实时服务是单独的检查：/v1/epochs/current/participants。moonshotai/Kimi-K2.6和zai-org/GLM-5.2-FP8仍保留在治理目录中，但已被提案101从poc_params中移除——它们不是PoC模型。GLM-5.3-Flash自轮次395（penalty_start_epoch 394）起为活跃PoC组；请参阅GLM-5.3-Flash引导。

如果您不运行所有批准的模型

多模型PoC按每个模型跟踪参与情况。对于您未运行的有资格模型，请使用链上委托或拒绝。仅对有资格的组适用常规的错过/拒绝惩罚。无投票权的已列模型是引导候选者；refuse不是必需的，也不是引导参与模式。委托/拒绝不是启动节点所必需的——您使用与向ML操作密钥授予权限中相同的账户（冷）密钥，在注册和验证之后。复制粘贴命令位于末尾：可选：PoC委托和拒绝。有关策略和惩罚，请阅读多模型PoC — 主机操作指南。有关GLM-5.3-Flash（自轮次394起的惩罚），请参阅GLM-5.3-Flash引导。

治理与模型分类

如果获得治理批准，模型可被归类到某一类别。
关于添加或更改支持模型的决策由治理做出。
有关治理程序及如何提出新模型的详细信息，请参阅交易与治理指南。

建议的硬件配置

要运行有效的节点，您需要配备支持的GPU的机器。以下是参考布局：

模型名称	ML节点（最少）	示例硬件	每个ML节点的最小VRAM
`MiniMaxAI/MiniMax-M2.7`	≥ 2	每个ML节点：4× A100 / 4× H100 / 2× H200 / 2× B200	~320 GB
`deepseek-ai/DeepSeek-V4-Flash-0731`	≥ 2	每个ML节点：4× H100 / 2× H200 / 2× B200 / 1× B300	~280 GB
`zai-org/GLM-5.3-Flash`	≥ 2	8× H100 / 4× H200 / 4× B200 / 2× B300 每个 MLNode	~560 GB

这是一个参考架构。您可以调整节点数量或硬件分配，但我们建议遵循核心原则：每个节点应支持所有模型层级的多个 ML 节点。

每个模型的 weight_scale_factor 值由治理设置 —— 请从 poc_params 中读取。系数仅在模型组有资格（具有投票权）时产生共识权重。参见 DeepSeek V4 Flash Bootstrap、GLM-5.3-Flash Bootstrap 和系数表。vLLM 参数示例见下面的 node-config.json 示例。

有关最优部署配置的更多详细信息，请参见此处。

托管网络节点的服务器应具备：

16 核 CPU (amd64)
64 GB 或更多 RAM
1TB NVMe SSD
最低 100Mbps 网络连接（建议 1Gbps）

最终要求将取决于连接的 ML 节点数量及其总吞吐量。

用于部署每个 ML 节点的服务器应具备：

至少为 GPU 显存容量的 1.5 倍的 RAM
16 核 CPU（网络节点和 ML 节点可部署在同一台服务器上）。
已安装并配置 NVIDIA Container Toolkit，CUDA Toolkit 版本介于 12.6 至 12.9 之间。您可以通过 nvidia-smi 检查版本。

网络访问、代理和端口（重要）

Gonka 网络采用基于代理的架构，以保护节点免受滥用和 DDoS 攻击。所有公共 HTTP/HTTPS 流量必须通过代理容器。直接暴露网络节点或 ML 节点服务是不安全的。

公开暴露的端口

以下端口可公开暴露于互联网：

5000 - Tendermint P2P 通信
8000 / 8443 - 仅通过代理的应用服务

警告：内部端口

以下端口为仅限内部使用，严禁公开访问：

26657 - Tendermint RPC
9100, 9200 — 网络节点内部 API
5050 — ML 节点 / vLLM 推理 API
8080 — ML 节点 API

如果这些端口中的任何一个被暴露于公共互联网，您的节点将面临风险。第三方可自由发送请求，使您的 ML 节点过载、干扰挖矿，或导致您的节点脱离一个纪元。

要求：

- 仅允许来自本地主机、私有网络或白名单的访问
- 绝不可公开暴露这些端口
- Docker 默认配置并不安全

从升级 0.2.8 开始

为默认增强安全性和性能，除非显式覆盖，否则将自动应用以下路由控制和链服务限制。

API Manual Routes Control

      # Defines which routes bypass rate limits (Exempt) vs those completely disabled (Blocked)
      - GONKA_API_EXEMPT_ROUTES=chat inference
      - GONKA_API_BLOCKED_ROUTES=poc-batches training

Chain Routes Disabling

      # Disables public access to Chain services by default
      - DISABLE_CHAIN_API=${DISABLE_CHAIN_API:-true}
      - DISABLE_CHAIN_RPC=${DISABLE_CHAIN_RPC:-true}
      - DISABLE_CHAIN_GRPC=${DISABLE_CHAIN_GRPC:-true}

以下情况描述了网络节点和 ML 节点服务的内部端口隔离。这些规则在代理被配置为唯一公共入口点后生效。它们不替代代理，必须与代理配合使用。

情况 1：ML 节点和网络节点在同一台机器上

将端口绑定到仅本地主机。

网络节点 (docker-compose.yml)

如果您的 ML 节点容器和网络节点容器在同一台机器上，您可以直接编辑 gonka/deploy/join/docker-compose.yml：

api:
    ports:
        - "127.0.0.1:9100:9100"
        - "127.0.0.1:9200:9200"

**ML 节点 (`docker-compose.mlnode.yml`)**
```
ports:
    - "127.0.0.1:${PORT:-8080}:8080"
    - "127.0.0.1:${INFERENCE_PORT:-5050}:5000"
```

请勿使用：

- "9100:9100"
- "9200:9200"
- "5050:5000"
- "8080:8080"

情况 2：ML 节点和网络节点位于不同机器上

在此设置中，网络节点与 ML 节点之间的所有通信必须通过私有网络进行。禁止使用公共 IP 或公共 DNS 名称进行：

ML 节点 API
DAPI_API__POC_CALLBACK_URL

如果 ML 节点和网络节点容器位于不同机器上，则情况 1 中描述的修复方法将无效，保护这些端口的具体方式取决于您的设置。您应通过使用相同的 Docker 网络，或在机器之间设置私有网络、在该网络中暴露端口并关闭公共端口，来建立 ML 节点与网络容器之间的连接。在此情况下，您还应在配置中正确设置 DAPI_API__POC_CALLBACK_URL 变量。此 URL 必须指向私有/内部地址，而非公共地址。

设置您的节点

快速入门指南旨在将网络节点和推理节点部署在同一台机器上（单服务器设置）。

多节点部署

如果您要部署多个 GPU 节点，请参阅详细的多节点部署指南以进行正确设置和配置。无论您是将推理节点部署在单台机器上还是跨多台服务器（包括跨地理区域），所有推理节点都必须连接到同一个网络节点。

密钥管理概述

在配置您的网络节点之前，您需要为安全操作设置加密密钥。
建议在启动生产节点前阅读密钥管理指南。

我们使用三密钥系统：

账户密钥（冷钱包）- 在您的本地安全机器上创建，用于高风险操作
共识密钥（TMKMS - 温存储）- 由安全的 TMKMS 服务管理，用于区块验证和网络共识参与
ML 运营密钥（温钱包）- 在服务器上创建，用于自动化 AI 工作负载交易

[本地机器] 安装 CLI 工具

inferenced CLI 是本地账户管理和网络操作所必需的。它是一个命令行界面工具，允许您在本地机器上创建和管理 Gonka 账户、注册主机以及执行各种网络操作。

选择正确的二进制文件

GitHub 发布版本可能包含多个 inferenced 文件。

对于本地 CLI 使用，请始终下载 特定操作系统的打包 CLI 构建，例如：

inferenced-darwin-amd64.zip
inferenced-darwin-arm64.zip
inferenced-linux-amd64.zip
inferenced-linux-arm64.zip

请勿使用专为升级路径或容器/运行时环境设计的通用 inferenced 二进制文件。这些文件可能无法在您的本地机器上作为独立 CLI 正常工作。

版本要求

请确保您使用的是 inferenced CLI 构建版本 0.2.9 或更新版本。旧版 CLI 不支持权限授予，可能导致意外行为。

如果您计划提交治理提案，尤其是使用较新消息类型的提案，请使用最新发布的特定操作系统 CLI 构建。

验证安装

chmod +x inferenced
./inferenced --help

macOS 用户

在 macOS 上，如果被提示，您可能需要在 System Settings → Privacy & Security 中允许执行。向下滚动到有关 inferenced 的警告并点击 Allow Anyway。

如果在 Linux 上二进制文件无法启动并出现类似 Error relocating ./inferenced: qsort_r: symbol not found 的错误，您很可能下载了非 CLI 或仅用于升级的工件，而非针对您操作系统的专用 CLI 构建。请重新下载适用于您操作系统和架构的正确归档文件。

[本地机器] 创建账户密钥

重要：请在安全的本地机器上执行此步骤（非您的服务器）

关于账户密钥（冷密钥）

账户密钥是您的主要高权限密钥。它在本地创建，绝不会存储在您的服务器上。

授予所有其他密钥权限的主密钥
必须离线存储在安全的气隙机器上
仅用于授予权限和验证者注册
由助记词保护 - 如果丢失，所有访问将永久失效

使用 file 密钥环后端创建您的账户密钥（在支持的系统上，您也可以使用 os 以获得更高安全性）：

./inferenced keys add gonka-account-key --keyring-backend file

CLI 将要求您输入密码短语，并显示已创建密钥对的信息。

❯ ./inferenced keys add gonka-account-key --keyring-backend file
Enter keyring passphrase (attempt 1/3):
Re-enter keyring passphrase:

- address: gonka1rk52j24xj9ej87jas4zqpvjuhrgpnd7h3feqmm
  name: gonka-account-key
  pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"Au+a3CpMj6nqFV6d0tUlVajCTkOP3cxKnps+1/lMv5zY"}'
  type: local


**Important** write this mnemonic phrase in a safe place.
It is the only way to recover your account if you ever forget your password.

pyramid sweet dumb critic lamp various remove token talent drink announce tiny lab follow blind awful expire wasp flavor very pair tell next cable

关键：请将此助记词写下来并安全地离线存储。此短语是唯一恢复您的账户密钥的方法。

硬件钱包支持

当前状态：在网络安全启动时，硬件钱包尚不支持。

目前：请将您的账户密钥存储在安全的专用机器上，该机器应尽量减少互联网暴露并启用强加密。

重要：无论未来是否采用硬件钱包，都请始终将助记词作为备份。

[服务器] 下载部署文件

克隆包含基础部署脚本的仓库：

git clone https://github.com/gonka-ai/gonka.git -b main && \
cd gonka/deploy/join

DeepSeek V4 Flash 和 MLNode 3.0.16

main 仍固定使用 MLNode 3.0.14-post2，且不包含 DeepSeek node-config-*.json 文件。要提供 deepseek-ai/DeepSeek-V4-Flash-0731，请改为克隆 vllm-0.25.1-upgrade：

git clone https://github.com/gonka-ai/gonka.git -b vllm-0.25.1-upgrade && \
cd gonka/deploy/join

该分支固定使用 ghcr.io/gonka-ai/mlnode:3.0.16（如果主机仍使用 CUDA 12.9，请使用 3.0.16-cu129 标签）。

GLM-5.3-Flash 和 MLNode 3.1.0

GLM-5.3-Flash 需要 vLLM 0.28、CUDA 13 驱动（580+）和镜像 ghcr.io/gonka-ai/mlnode:3.1.0-vllm-0.28.0。请勿对 GLM 使用 3.0.17。请克隆 feat/glm-5-3-flash-release 以获取提供的 node-config-glm53flash-*.json 文件（gonka-ai/gonka#1734）：

git clone https://github.com/gonka-ai/gonka.git -b feat/glm-5-3-flash-release && \
cd gonka/deploy/join

在 8×H100 上设置 POC_BATCH_SIZE_DEFAULT 为 8，在 H200 上设置为 16，在 B200/B300 上设置为 32。在 NVSwitch VM 上设置 NCCL_NVLS_ENABLE=0。参见 GLM-5.3-Flash 启动。

并复制 config 文件模板：

cp config.env.template config.env

克隆仓库后，您将找到以下关键配置文件：

文件	描述
`config.env`	包含网络节点的环境变量
`docker-compose.yml`	用于启动网络节点的 Docker Compose 文件
`docker-compose.mlnode.yml`	用于启动 ML 节点的 Docker Compose 文件
`node-config.json`	网络节点使用的配置文件，描述了此网络节点管理的推理节点

[服务器] 设置环境变量

配置必需

请完成问卷以生成您的 config.env 配置。环境变量取决于您的选择（HTTP/HTTPS、SSL 证书方法等）。

无域名时无法使用 HTTPS

SSL/TLS 证书只能为域名（例如 example.com）颁发，不能为直接 IP 地址颁发。由于您表示未配置域名，您的节点将仅配置为 HTTP（端口 8000）。

如果您需要 HTTPS 安全性，您需要：

获取一个域名，并配置 DNS 指向您的服务器 IP 地址
点击上方的 "重置" 按钮，并在询问是否拥有域名时选择 "是"

对于生产部署，强烈建议使用 HTTPS 来加密 API 通信并保护敏感数据。

如果您的节点无法连接到默认种子节点，请查看 FAQ 了解详情。

[服务器] 编辑环境变量

需要编辑的变量：

其他所有变量可保持不变。

如何从域名提供商获取变量：

Cloudflare

1) 打开 Cloudflare 仪表板。

2) 转到 Profile → API Tokens。

3) 点击 Create Token。

4) 使用 Edit zone DNS 模板，或设置权限：Zone:Read 和 DNS:Edit。

5) 将令牌限制为您的 DNS 区域并创建它。

6) 复制令牌并设置 CF_DNS_API_TOKEN。

AWS Route53

选项 A — AWS CLI

HOSTED_ZONE_ID="Z123EXAMPLE"
cat > route53-acme.json <<'JSON'
{
"Version": "2012-10-17",
"Statement": [
    {
    "Effect": "Allow",
    "Action": ["route53:ChangeResourceRecordSets"],
    "Resource": "arn:aws:route53:::hostedzone/${HOSTED_ZONE_ID}"
    },
    {
    "Effect": "Allow",
    "Action": [
        "route53:ListHostedZones",
        "route53:ListHostedZonesByName",
        "route53:ListResourceRecordSets",
        "route53:GetChange"
    ],
    "Resource": "*"
    }
]
}
JSON

aws iam create-policy \
--policy-name acme-dns-route53-${HOSTED_ZONE_ID} \
--policy-document file://route53-acme.json | jq -r .Policy.Arn

USER_NAME="acme-dns"
POLICY_ARN=$(aws iam list-policies --query "Policies[?PolicyName=='acme-dns-route53-${HOSTED_ZONE_ID}'].Arn" -o tsv)
aws iam create-user --user-name "$USER_NAME" >/dev/null || true
aws iam attach-user-policy --user-name "$USER_NAME" --policy-arn "$POLICY_ARN"
CREDS=$(aws iam create-access-key --user-name "$USER_NAME")
AWS_ACCESS_KEY_ID=$(echo "$CREDS" | jq -r .AccessKey.AccessKeyId)
AWS_SECRET_ACCESS_KEY=$(echo "$CREDS" | jq -r .AccessKey.SecretAccessKey)

echo "AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID"
echo "AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY"
echo "AWS_REGION=<your-aws-region>"

选项 B — 控制台

1) 创建一个仅限于您的托管区域的 IAM 策略（ChangeResourceRecordSets 和列出权限）。

2) 创建一个具有编程访问权限的 IAM 用户。

3) 将策略附加到该用户。

4) 创建访问密钥对，并设置 AWS_ACCESS_KEY_ID、AWS_SECRET_ACCESS_KEY 和 AWS_REGION。

Google Cloud DNS

选项 A — gcloud CLI：

PROJECT_ID="<your-gcp-project>"
SA_NAME="acme-dns"
SA_EMAIL="$SA_NAME@$PROJECT_ID.iam.gserviceaccount.com"

gcloud config set project "$PROJECT_ID"
# 1) Service account
gcloud iam service-accounts create "$SA_NAME" \
--display-name "ACME DNS for proxy-ssl"
# 2) Role
gcloud projects add-iam-policy-binding "$PROJECT_ID" \
--member "serviceAccount:$SA_EMAIL" \
--role "roles/dns.admin"
# 3) Key → base64 (single line)
gcloud iam service-accounts keys create key.json --iam-account "$SA_EMAIL"
GCE_SERVICE_ACCOUNT_JSON_B64=$(base64 < key.json | tr -d '\n')

echo "GCE_PROJECT=$PROJECT_ID"
echo "GCE_SERVICE_ACCOUNT_JSON_B64=$GCE_SERVICE_ACCOUNT_JSON_B64"

选项 B — 控制台

1) IAM & Admin → 服务账号 → 创建服务账号（例如 acme-dns）。

2) 为服务账号授予角色：DNS 管理员（roles/dns.admin）。

3) 服务账号 → 密钥 → 添加密钥 → 创建新密钥（JSON）→ 下载。

4) 将 JSON 密钥 Base64 编码为单行，并设置 GCE_SERVICE_ACCOUNT_JSON_B64。将 GCE_PROJECT 设置为您的项目 ID。

Azure DNS

选项 A — Azure CLI（快速）

# 1) Login and choose subscription
az login
az account set --subscription "<your-subscription-name-or-id>"

# 2) Set where your DNS zone lives
RG="<<your-dns-resource-group>>"
ZONE="<<your-zone>>"         # e.g., gonka.ai
SP_NAME="gonka-acme-$(date +%s)"

SUBSCRIPTION_ID=$(az account show --query id -o tsv)
SCOPE="/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RG/providers/Microsoft.Network/dnszones/$ZONE"

CREDS=$(az ad sp create-for-rbac \
--name "$SP_NAME" \
--role "DNS Zone Contributor" \
--scopes "$SCOPE" \
--only-show-errors)

# 4) Extract values
AZURE_CLIENT_ID=$(echo "$CREDS" | jq -r .appId)
AZURE_CLIENT_SECRET=$(echo "$CREDS" | jq -r .password)
AZURE_TENANT_ID=$(echo "$CREDS" | jq -r .tenant)

# 5) Print for your env file
echo "AZURE_CLIENT_ID=$AZURE_CLIENT_ID"
echo "AZURE_CLIENT_SECRET=$AZURE_CLIENT_SECRET"
echo "AZURE_SUBSCRIPTION_ID=$SUBSCRIPTION_ID"
echo "AZURE_TENANT_ID=$AZURE_TENANT_ID"

选项 B — 门户

1) 转到 Microsoft Entra ID → 应用注册 → 新注册。复制应用程序（客户端）ID 和目录（租户）ID。

2) 转到证书和密钥 → 新客户端密钥。复制密钥值并设置 AZURE_CLIENT_SECRET。

3) 复制您的订阅 ID 并设置 AZURE_SUBSCRIPTION_ID。

4) 在您的 DNS 区域中，打开访问控制（IAM）→ 添加角色分配 → DNS 区域参与者 → 分配给已注册的应用。

DigitalOcean DNS

1) 打开 DigitalOcean 控制面板。

2) 转到 API → Tokens。

3) 生成一个具有写入权限的令牌并设置 DO_AUTH_TOKEN。

Hetzner DNS

1) 打开 https://dns.hetzner.com.

2) 转到 API Tokens.

3) 创建一个新令牌并设置 HETZNER_API_KEY.

加载配置:

source config.env

使用环境变量

以下各节中的示例将引用这些环境变量（例如 $PUBLIC_URL、$ACCOUNT_PUBKEY、$SEED_API_URL），适用于本地机器命令和服务器命令。请确保在每个将执行这些命令的终端会话中运行 source config.env。

[服务器] 编辑服务器的推理节点描述

Note

选择与您将要部署的模型和 GPU 类别匹配的标签。确认模型位于 GET /v1/governance/models。资格（投票权，confirmation_weight_scales）和实时服务（/v1/epochs/current/participants）与此目录无关。moonshotai/Kimi-K2.6 和 zai-org/GLM-5.2-FP8 在提案 101 之后不再是 PoC 模型。模型治理决定添加或修改支持的模型。有关模型治理的工作方式以及如何提出新模型的详细信息，请参阅交易与治理指南。

Kimi — 4×B200 / 8×B200（以及 8×H200 参考类别)

不是 PoC 模型（提案 101)

moonshotai/Kimi-K2.6 已被提案 101 从 poc_params.models 中移除。它仍保留在 GET /v1/governance/models（推理目录）中，但切换到它不会获得 PoC 共识权重。这些参数是最后已知的部署形态。

有关当前的 PoC 集（MiniMax、DeepSeek、GLM-5.3-Flash），请参阅其他标签和 GLM-5.3-Flash 启动。原始的 Kimi 启动记录在 Kimi K2.6 启动中。

对于 Kimi K2.6 在 Blackwell 4×B200 或 8×B200 上，以及作为 8×H200 在相同布局下的参考（tensor_parallel_size 4 个专家并行分布在八个 GPU 上），请使用此 vLLM 参数集。仅在您的堆栈或基准测试需要时进行调整。

仓库中的参考部署配置：deploy/join/node-config-kimik26-B200.json.

编辑 node-config.json

[
    {
        "id": "node1",
        "host": "inference",
        "inference_port": 5000,
        "poc_port": 8080,
        "max_concurrent": 500,
        "models": {
            "moonshotai/Kimi-K2.6": {
                "args": [
                    "--tensor-parallel-size", "4",
                    "--enable-expert-parallel",
                    "--trust-remote-code",
                    "--mm-encoder-tp-mode", "data",
                    "--tool-call-parser", "kimi_k2",
                    "--reasoning-parser", "kimi_k2",
                    "--attention-backend", "FLASHINFER_MLA",
                    "--disable-custom-all-reduce",
                    "--gpu-memory-utilization", "0.95",
                    "--max-num-seqs", "128",
                    "--max-model-len", "240000"
                ]
            }
        }
    }
]

通过API注册或更新节点时使用相同的"models"块；有关等效的curl示例，请参见Kimi K2.6 Bootstrap。

Kimi — 8×H200

仓库中的参考部署配置：deploy/join/node-config-kimik26-H200.json。在所有GPU上使用FLASHMLA注意力和tensor_parallel_size=8，无需专家并行。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "moonshotai/Kimi-K2.6": {
                    "args": [
                        "--tensor-parallel-size", "8",
                        "--enable-expert-parallel",
                        "--trust-remote-code",
                        "--mm-encoder-tp-mode", "data",
                        "--tool-call-parser", "kimi_k2",
                        "--reasoning-parser", "kimi_k2",
                        "--attention-backend", "FLASHMLA",
                        "--gpu-memory-utilization", "0.90",
                        "--max-model-len", "240000"
                    ]
                }
            }
        }
    ]
    ```

MiniMax — 4×A100

为MiniMax M2.7在4×A100上使用此vLLM参数集。A100无法使用FP8 FlashInfer MoE路径，因此此配置使用marlin MoE后端。您还需要为mlnode-308服务设置环境变量VLLM_USE_FLASHINFER_MOE_FP8=0（MLNode 3.0.14自带的配置中已预先设置）。

仓库中的参考部署配置：deploy/join/node-config-minimaxm27-A100.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "MiniMaxAI/MiniMax-M2.7": {
                    "args": [
                        "--moe-backend", "marlin",
                        "--tensor-parallel-size", "4",
                        "--gpu-memory-utilization", "0.95",
                        "--max-num-seqs", "128",
                        "--enable-auto-tool-choice",
                        "--max-model-len", "180000",
                        "--kv-cache-dtype", "fp8",
                        "--tool-call-parser", "minimax_m2",
                        "--reasoning-parser", "minimax_m2_append_think"
                    ]
                }
            }
        }
    ]
    ```

MiniMax — 4×H100

为MiniMax M2.7在4×H100上使用此vLLM参数集。使用FLASHINFER注意力后端和FP8 kv-cache。

仓库中的参考部署配置：deploy/join/node-config-minimaxm27-H100.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "MiniMaxAI/MiniMax-M2.7": {
                    "args": [
                        "--tensor-parallel-size", "4",
                        "--attention-backend", "FLASHINFER",
                        "--gpu-memory-utilization", "0.92",
                        "--max-num-seqs", "128",
                        "--enable-auto-tool-choice",
                        "--max-model-len", "180000",
                        "--kv-cache-dtype", "fp8",
                        "--tool-call-parser", "minimax_m2",
                        "--reasoning-parser", "minimax_m2_append_think"
                    ]
                }
            }
        }
    ]
    ```

MiniMax — 2×H200

为MiniMax M2.7在2×H200上使用此vLLM参数集（MiniMax的Hopper参考类别）。使用FLASHINFER注意力后端、FP8 kv-cache和tensor_parallel_size=2。MiniMax M2.7的PoC黄金向量在此确切配置下记录。

仓库中的参考部署配置：deploy/join/node-config-minimaxm27-H200.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "MiniMaxAI/MiniMax-M2.7": {
                    "args": [
                        "--tensor-parallel-size", "2",
                        "--attention-backend", "FLASHINFER",
                        "--gpu-memory-utilization", "0.92",
                        "--max-num-seqs", "128",
                        "--enable-auto-tool-choice",
                        "--max-model-len", "180000",
                        "--kv-cache-dtype", "fp8",
                        "--tool-call-parser", "minimax_m2",
                        "--reasoning-parser", "minimax_m2_append_think"
                    ]
                }
            }
        }
    ]
    ```

MiniMax — 2×B200

为MiniMax M2.7在2×B200上使用此vLLM参数集（MiniMax的Blackwell参考类别）。使用FLASHINFER_TRTLLM MoE后端、FP8 kv-cache和tensor_parallel_size=2。

仓库中的参考部署配置：deploy/join/node-config-minimaxm27-B200.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "MiniMaxAI/MiniMax-M2.7": {
                    "args": [
                        "--tensor-parallel-size", "2",
                        "--moe-backend", "FLASHINFER_TRTLLM",
                        "--gpu-memory-utilization", "0.92",
                        "--max-num-seqs", "128",
                        "--enable-auto-tool-choice",
                        "--max-model-len", "180000",
                        "--kv-cache-dtype", "fp8",
                        "--tool-call-parser", "minimax_m2",
                        "--reasoning-parser", "minimax_m2_append_think"
                    ]
                }
            }
        }
    ]
    ```

DeepSeek — 4×H100

为DeepSeek V4 Flash在4×H100上使用此vLLM参数集。DeepSeek需要MLNode 3.0.16（vLLM 0.25.1）。

仓库中的参考部署配置：deploy/join/node-config-deepseekv4flash0731-H100.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "deepseek-ai/DeepSeek-V4-Flash-0731": {
                    "args": [
                        "--revision", "7872f01b1d1fe23eabc4c98b48bffcef5a386062",
                        "--tensor-parallel-size", "4",
                        "--gpu-memory-utilization", "0.85",
                        "--max-model-len", "400000",
                        "--max-num-batched-tokens", "32768",
                        "--kv-cache-dtype", "fp8",
                        "--tokenizer-mode", "deepseek_v4",
                        "--enable-auto-tool-choice",
                        "--tool-call-parser", "deepseek_v4",
                        "--reasoning-parser", "deepseek_v4",
                        "--trust-remote-code"
                    ]
                }
            }
        }
    ]
    ```

DeepSeek — 2×H200

为DeepSeek V4 Flash在2×H200上使用此vLLM参数集。DeepSeek需要MLNode 3.0.16（vLLM 0.25.1）。

仓库中的参考部署配置：deploy/join/node-config-deepseekv4flash0731-H200.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "deepseek-ai/DeepSeek-V4-Flash-0731": {
                    "args": [
                        "--revision", "7872f01b1d1fe23eabc4c98b48bffcef5a386062",
                        "--tensor-parallel-size", "2",
                        "--gpu-memory-utilization", "0.90",
                        "--max-model-len", "400000",
                        "--max-num-batched-tokens", "32768",
                        "--kv-cache-dtype", "fp8",
                        "--tokenizer-mode", "deepseek_v4",
                        "--enable-auto-tool-choice",
                        "--tool-call-parser", "deepseek_v4",
                        "--reasoning-parser", "deepseek_v4",
                        "--trust-remote-code"
                    ]
                }
            }
        }
    ]
    ```

DeepSeek — 2×B200

为DeepSeek V4 Flash在2×B200上使用此vLLM参数集。DeepSeek需要MLNode 3.0.16（vLLM 0.25.1）。为在Blackwell上获得更好性能，请使用nvfp4变体node-config-deepseekv4flash0731-B200-nvfp4.json（model_override至MJPansa/DeepSeek-V4-Flash-0731-NVFP4）；该格式需要API v0.2.15-post5——参见网络更新。

仓库中的参考部署配置：deploy/join/node-config-deepseekv4flash0731-B200.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "deepseek-ai/DeepSeek-V4-Flash-0731": {
                    "args": [
                        "--revision", "7872f01b1d1fe23eabc4c98b48bffcef5a386062",
                        "--tensor-parallel-size", "2",
                        "--gpu-memory-utilization", "0.90",
                        "--max-model-len", "400000",
                        "--max-num-batched-tokens", "32768",
                        "--kv-cache-dtype", "fp8",
                        "--tokenizer-mode", "deepseek_v4",
                        "--enable-auto-tool-choice",
                        "--tool-call-parser", "deepseek_v4",
                        "--reasoning-parser", "deepseek_v4",
                        "--trust-remote-code"
                    ]
                }
            }
        }
    ]
    ```

DeepSeek — 1×B300

为DeepSeek V4 Flash在1×B300上使用此vLLM参数集。DeepSeek需要MLNode 3.0.16（vLLM 0.25.1）。在B300上，这是当前系数（0.246）下权重最高的PoC选项。为获得更好性能，请使用nvfp4变体node-config-deepseekv4flash0731-B300-nvfp4.json（model_override至MJPansa/DeepSeek-V4-Flash-0731-NVFP4）；该格式需要API v0.2.15-post5——参见网络更新。

仓库中的参考部署配置：deploy/join/node-config-deepseekv4flash0731-B300.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "deepseek-ai/DeepSeek-V4-Flash-0731": {
                    "args": [
                        "--revision", "7872f01b1d1fe23eabc4c98b48bffcef5a386062",
                        "--tensor-parallel-size", "1",
                        "--gpu-memory-utilization", "0.90",
                        "--max-model-len", "400000",
                        "--max-num-batched-tokens", "32768",
                        "--kv-cache-dtype", "fp8",
                        "--tokenizer-mode", "deepseek_v4",
                        "--enable-auto-tool-choice",
                        "--tool-call-parser", "deepseek_v4",
                        "--reasoning-parser", "deepseek_v4",
                        "--trust-remote-code"
    ]
    ```

GLM — 8×H100

为GLM-5.3-Flash在8×H100上使用此vLLM参数集。GLM需要MLNode 3.1.0（vLLM 0.28，CUDA 13）。设置POC_BATCH_SIZE_DEFAULT=8。

仓库中的参考部署配置：在feat/glm-5-3-flash-release上使用deploy/join/node-config-glm53flash-H100.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "zai-org/GLM-5.3-Flash": {
                    "args": [
                        "--revision", "04c4e9e95c5da8862dced7e5056455116f83a7e0",
                        "--tensor-parallel-size", "8",
                        "--gpu-memory-utilization", "0.95",
                        "--max-num-batched-tokens", "16384",
                        "--kv-cache-dtype", "fp8",
                        "--block-size", "2304",
                        "--max-num-seqs", "256",
                        "--no-enable-flashinfer-autotune",
                        "--enable-auto-tool-choice",
                        "--tool-call-parser", "glm47",
                        "--reasoning-parser", "glm45",
                        "--trust-remote-code"
                    ]
                }
            }
        }
    ]
    ```

GLM — 4×H200

使用此 vLLM 参数集在 4×H200 上运行 GLM-5.3-Flash。GLM 需要 MLNode 3.1.0（vLLM 0.28，CUDA 13）。设置 POC_BATCH_SIZE_DEFAULT=16。对于 8×H200，运行两个 4-GPU 实例（node-config-glm53flash-8xH200.json）。

仓库中的参考部署配置：deploy/join/node-config-glm53flash-H200.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "zai-org/GLM-5.3-Flash": {
                    "args": [
                        "--revision", "04c4e9e95c5da8862dced7e5056455116f83a7e0",
                        "--tensor-parallel-size", "4",
                        "--gpu-memory-utilization", "0.90",
                        "--max-num-batched-tokens", "16384",
                        "--kv-cache-dtype", "fp8",
                        "--block-size", "2304",
                        "--max-num-seqs", "256",
                        "--no-enable-flashinfer-autotune",
                        "--enable-auto-tool-choice",
                        "--tool-call-parser", "glm47",
                        "--reasoning-parser", "glm45",
                        "--trust-remote-code"
                    ]
                }
            }
        }
    ]
    ```

GLM — 4×B200

使用此 vLLM 参数集在 4×B200 上运行 GLM-5.3-Flash。GLM 需要 MLNode 3.1.0（vLLM 0.28，CUDA 13）。在 B200 上，这是当前系数（0.62）下的预期 PoC 切换。设置 POC_BATCH_SIZE_DEFAULT=32。在 NVSwitch VM 上设置 NCCL_NVLS_ENABLE=0。

仓库中的参考部署配置：deploy/join/node-config-glm53flash-B200.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "zai-org/GLM-5.3-Flash": {
                    "args": [
                        "--revision", "04c4e9e95c5da8862dced7e5056455116f83a7e0",
                        "--tensor-parallel-size", "4",
                        "--gpu-memory-utilization", "0.90",
                        "--max-num-batched-tokens", "65536",
                        "--kv-cache-dtype", "fp8",
                        "--block-size", "2304",
                        "--max-num-seqs", "256",
                        "--no-enable-flashinfer-autotune",
                        "--enable-auto-tool-choice",
                        "--tool-call-parser", "glm47",
                        "--reasoning-parser", "glm45",
                        "--trust-remote-code"
                    ]
                }
            }
        }
    ]
    ```

GLM — 2×B300

使用此 vLLM 参数集在 2×B300 上运行 GLM-5.3-Flash。GLM 需要 MLNode 3.1.0（vLLM 0.28，CUDA 13）。在当前系数下，DeepSeek 在 B300 上仍是权重最高的选项；此配置为可选。设置 POC_BATCH_SIZE_DEFAULT=32。在 NVSwitch VM 上设置 NCCL_NVLS_ENABLE=0。

仓库中的参考部署配置：deploy/join/node-config-glm53flash-B300.json。

!!! note "edit node-config.json"
    ```
    [
        {
            "id": "node1",
            "host": "inference",
            "inference_port": 5000,
            "poc_port": 8080,
            "max_concurrent": 500,
            "models": {
                "zai-org/GLM-5.3-Flash": {
                    "args": [
                        "--revision", "04c4e9e95c5da8862dced7e5056455116f83a7e0",
                        "--tensor-parallel-size", "2",
                        "--gpu-memory-utilization", "0.90",
                        "--max-num-batched-tokens", "65536",
                        "--kv-cache-dtype", "fp8",
                        "--block-size", "2304",
                        "--max-num-seqs", "256",
                        "--no-enable-flashinfer-autotune",
                        "--enable-auto-tool-choice",
                        "--tool-call-parser", "glm47",
                        "--reasoning-parser", "glm45",
                        "--trust-remote-code"
                    ]
                }
            }
        }
    ]
    ```

有关最优部署配置的更多详情，请参阅此链接。

Validate the deployment

gonka 仓库提供了一个代理技能 mlnode-validate，用于根据预计算的诚实 PoC 向量验证 ML Node 是否符合特定模型。使用与您部署模型匹配的黄金参考（MiniMax-M2.7、DeepSeek V4 Flash 在 vllm-0.25.1-upgrade，或 GLM-5.3-Flash 在 feat/glm-5-3-flash-release）。Qwen3-0.6B / Qwen3-235B 的工件为历史版本，不是主网模型。参见验证 ML Node 部署。

[Server] 预下载模型权重到 Hugging Face 缓存 (HF_HOME)

推理节点从 Hugging Face 下载模型权重。为确保模型权重在部署前已就绪，您应在部署前下载它们。

Kimi K2.6

moonshotai/Kimi-K2.6 在提案 101 后不再是 PoC 模型。仅当您打算从治理推理目录提供服务时才下载它。将 node-config 切换为 Kimi 不会恢复 PoC 共识权重。有关历史记录，请参阅 Kimi K2.6 启动。

```bash
mkdir -p $HF_HOME
huggingface-cli download moonshotai/Kimi-K2.6
```

模型许可证：参见 [模型许可证](../model-licenses.md)。

MiniMax M2.7DeepSeek V4 FlashGLM-5.3-Flash

mkdir -p $HF_HOME
huggingface-cli download MiniMaxAI/MiniMax-M2.7

模型许可证：参见模型许可证。MiniMax M2.7 需要 MLNode 3.0.14 或更高版本（镜像 ghcr.io/gonka-ai/mlnode:3.0.14-cu129，在 deploy/join/docker-compose.mlnode.yml 中固定）。在 A100 硬件上，还需确保为 mlnode-308 服务设置 VLLM_USE_FLASHINFER_MOE_FP8=0 环境变量（在提供的 compose 文件中已预设）。

mkdir -p $HF_HOME
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash-0731 --revision 7872f01b1d1fe23eabc4c98b48bffcef5a386062

模型许可证：参见模型许可证。DeepSeek V4 Flash 需要 MLNode 3.0.16 或更高版本（镜像 ghcr.io/gonka-ai/mlnode:3.0.16，在 vllm-0.25.1-upgrade 分支的 deploy/join/docker-compose.mlnode.yml 中固定；如果主机仍使用 CUDA 12.9，请使用 3.0.16-cu129 标签）。有关操作说明和链上选项（意图、委托），请参阅 DeepSeek V4 Flash 启动。在 Blackwell GPU 上，nvfp4 重新打包 MJPansa/DeepSeek-V4-Flash-0731-NVFP4 需要 API v0.2.15-post5 —— 请参阅网络更新。

mkdir -p $HF_HOME
huggingface-cli download zai-org/GLM-5.3-Flash --revision 04c4e9e95c5da8862dced7e5056455116f83a7e0

模型许可证：参见模型许可证。GLM-5.3-Flash 需要 MLNode 3.1.0（镜像 ghcr.io/gonka-ai/mlnode:3.1.0-vllm-0.28.0）、vLLM 0.28 和 CUDA 13 驱动（580+）。请勿使用 3.0.17。有关操作说明和链上选项（意图、委托），请参阅 GLM-5.3-Flash 启动。

启动节点

[Server] 拉取 Docker 镜像（容器）

在运行以下命令前，请确保您位于 gonka/deploy/join 文件夹中。

docker compose -f docker-compose.yml -f docker-compose.mlnode.yml pull

[服务器] 启动初始服务

启动密钥设置所需的必要服务（不包括API服务）：

source config.env && \
docker compose up tmkms node -d --no-deps

我们首先启动这些特定容器，因为：

tmkms - 生成并安全管理验证者注册所需的共识密钥
node - 连接到区块链并提供RPC端点以检索共识密钥
api - 在此阶段故意排除，因为我们需要在下一步中在其内部创建ML操作密钥

建议

您可以查看日志以确认初始服务已成功启动：

docker compose logs tmkms node -f

如果看到链节点持续处理区块事件，则说明设置正常运行。

关于共识密钥

由安全的TMKMS服务管理
温存储并防止双重签名
区块验证和网络共识参与
可由账户密钥或授权委托人轮换

在步骤3.2.（inferenced register-new-participant）的注册命令期间，共识密钥将与您的账户密钥（冷密钥）在链上关联，使您的节点成为网络中的有效参与者。

如果您删除或覆盖了 .tmkms 文件夹，您的共识密钥将丢失。此密钥是将您的节点与区块链验证者集关联的关键。一旦 .tmkms 消失，您必须从头开始整个设置，包括生成新的共识密钥（通过 tmkms）（参见FAQ页面中的“我清除了或覆盖了我的共识密钥”）。

完成密钥设置和主机注册

现在我们需要通过创建温密钥、注册主机并授予权限来完成密钥管理设置：

3.1. [服务器] 创建ML操作密钥

关于ML操作密钥（温密钥）

由账户密钥授权用于ML特定交易
服务器上的加密文件，通过程序访问
自动化交易（推理请求、证明提交、奖励）
可随时由账户密钥轮换或撤销
需要持续可用，除非必要，请勿删除或轮换。

在 api 容器内使用 file 密钥环后端创建温密钥（程序访问所需）。密钥将存储在映射到容器 /root/.inference 的持久卷中：

docker compose run --rm --no-deps -it api /bin/sh

在容器内创建ML操作密钥：

printf '%s\n%s\n' "$KEYRING_PASSWORD" "$KEYRING_PASSWORD" | inferenced keys add "$KEY_NAME" --keyring-backend file

重要

请勿重复运行此命令。 ML操作密钥（温密钥）每个服务器仅生成一次，必须在重启后保留。

如果您意外删除或重新初始化，请遵循FAQ中的恢复说明： “我删除了温密钥”.
重启节点时，请完全跳过此步骤——密钥已生成并持久存储在API容器内。

示例输出：

~ # printf '%s\n%s\n' "$KEYRING_PASSWORD" "$KEYRING_PASSWORD" | inferenced keys add "$KEY_NAME" --keyring-backend file

- address: gonka1gyz2agg5yx49gy2z4qpsz9826t6s9xev6tkehw
  name: node-702105
  pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"Ao8VPh5U5XQBcJ6qxAIwBbhF/3UPZEwzZ9H/qbIA6ipj"}'
  type: local


**Important** write this mnemonic phrase in a safe place.
It is the only way to recover your account if you ever forget your password.

again plastic athlete arrow first measure danger drastic wolf coyote work memory already inmate sorry path tackle custom write result west tray rabbit jeans

3.2. [服务器] 注册主机

在同一容器内注册主机——这将在链上将您的URL、账户密钥和共识密钥（自动获取）关联起来：

inferenced register-new-participant \
    $DAPI_API__PUBLIC_URL \
    $ACCOUNT_PUBKEY \
    --node-address $DAPI_CHAIN_NODE__SEED_API_URL

预期输出：

...
Found participant: gonka1rk52j24xj9ej87jas4zqpvjuhrgpnd7h3feqmm (url: http://36.189.234.237:19250, status: ACTIVE)
Participant is now available at http://36.189.234.237:19250/v2/participants/gonka1rk52j24xj9ej87jas4zqpvjuhrgpnd7h3feqmm
Account balance: 0

账户已拥有GNK但尚未发送任何交易

在大多数情况下，inferenced register-new-participant 可直接从 api 容器内注册您的主机。

但是存在一个已知的边缘情况：如果您的账户密钥地址已收到GNK但从未发送过交易，从容器内注册可能会失败，并出现类似以下错误：

rpc error: code = Unknown desc = runtime error: invalid memory address or nil pointer dereference: panic

当账户有余额但链上交易序列仍为 0 时，可能发生这种情况。

如果上述命令因该错误失败，您可以通过您的本地机器检查账户余额和序列：

```bash
./inferenced query auth account <YOUR_COLD_ADDRESS> \
  --node <node-url>/chain-rpc/ \
  --output json | jq -r '.account.value.sequence // .sequence // "0"'
```

如果账户有非零的 `ngonka` 余额且序列命令返回 `0`，请使用以下手动注册流程。

步骤 1. 仍在步骤 3.1 的容器中时，获取您的共识密钥并记录下来：

curl -s $DAPI_CHAIN_NODE__URL/status | jq -r '.result.validator_info.pub_key.value'

**步骤 2.** 退出容器，然后在您的**本地机器**（存储您的账户密钥的地方）运行此命令：
```bash
./inferenced tx inference submit-new-participant \
    <PUBLIC_URL> \
    --validator-key <CONSENSUS_KEY> \
    --keyring-backend file \
    --from <COLD_KEY_NAME> \
    --timeout-duration 1m \
    --unordered \
    --node <node-url>/chain-rpc/ \
    --chain-id gonka-mainnet
```

`<node-url>` — 网络上任何已运行的节点（例如 `http://node2.gonka.ai:8000`）。在此步骤中不要使用您自己的节点 URL — 它尚未完全启动。

如果您使用自定义 --keyring-dir 创建了账户密钥，请在命令中添加 --keyring-dir <path>。

该命令将提示 confirm transaction before signing and broadcasting [y/N]: — 输入 y 继续。

手续费从账户密钥的余额中支付。运行此命令前请确保账户中有代币。

每个节点的账户密钥配置

为每个网络节点生成唯一的 ACCOUNT_PUBKEY，以确保主机之间的正确隔离。

然后我们可以退出容器：

exit

3.3. [本地机器] 为 ML 运营密钥授予权限

重要：请在创建账户密钥的安全本地机器上执行此步骤

从您的账户密钥向 ML 运营密钥授予权限。这还将创建一个默认支出限额为 10 GNK 的 feegrant（冷账户 → 温账户），以便 API 可以从冷账户支付手续费交易。如果此配额后来被用尽，您无法直接补充 — 必须撤销并重新授予；请参阅刷新 feegrant。

./inferenced tx inference grant-ml-ops-permissions \
    gonka-account-key \
    <ml-operational-key-address-from-step-3.1> \
    --from gonka-account-key \
    --keyring-backend file \
    --gas 2000000 \
    --node <seed_api_url from server's config.env>/chain-rpc/

预期输出：

...
Transaction sent with hash: FB9BBBB5F8C155D0732B290C443A0D06BC114CDF43E8EE8FB329D646C608062E
Waiting for transaction to be included in a block...

Transaction confirmed successfully!
Block height: 174

3.4. [服务器] 手动 SSL 证书设置

如果您在上述问卷中选择了手动 SSL 证书设置，请按照以下步骤配置您的 SSL 证书：

准备目录

mkdir -p secrets/nginx-ssl secrets/certbot

生成证书（Dockerized Certbot；DNS‑01）

DOMAIN=<FULL_DOMAIN_NAME>
ACCOUNT_EMAIL=<EMAIL_ADDRESS>    # renewal notices
mkdir -p secrets/nginx-ssl secrets/certbot

docker run --rm -it \
  -v "$(pwd)/secrets/certbot:/etc/letsencrypt" \
  -v "$(pwd)/secrets/nginx-ssl:/mnt/nginx-ssl" \
  certbot/certbot certonly --manual --preferred-challenges dns \
  -d "$DOMAIN" --email "$ACCOUNT_EMAIL" --agree-tos --no-eff-email \
  --deploy-hook 'install -m 0644 "$RENEWED_LINEAGE/fullchain.pem" /mnt/nginx-ssl/cert.pem; \
                 install -m 0600 "$RENEWED_LINEAGE/privkey.pem"   /mnt/nginx-ssl/private.key'

DNS 挑战

Certbot 将暂停并显示您在提供商处需要添加的 TXT DNS 记录。验证通过后，cert.pem 和 private.key 将出现在 ./secrets/nginx-ssl/ 中。

验证证书文件

确保证书文件已就位：

ls -la secrets/nginx-ssl/

您应该看到： - cert.pem（完整链证书） - private.key（权限为 0600 的私钥）

问卷生成的 config.env 文件已包含必要的 SSL 配置变量： - SERVER_NAME=<FULL_DOMAIN_NAME> - SSL_CERT_SOURCE=./secrets/nginx-ssl

继续前请确保使用您的实际域名编辑 SERVER_NAME。

[服务器] 启动完整节点

最后，启动所有容器，包括 API：

需要配置

请完成上方的问卷以生成启动命令。

启动所有容器：

source config.env && \
docker compose -f docker-compose.yml -f docker-compose.mlnode.yml up -d

使用自动 SSL 证书管理启动所有容器：

source config.env && \
docker compose --profile "ssl" \
  -f docker-compose.yml -f docker-compose.mlnode.yml \
  up -d

--profile "ssl" 标志启用了 proxy-ssl 容器，该容器自动管理 SSL 证书。

使用手动SSL证书启动所有容器:

source config.env && \
docker compose -f docker-compose.yml -f docker-compose.mlnode.yml up -d

验证节点状态

验证HTTPS是否正常工作:

curl -I https://<FULL_DOMAIN_NAME>:8443/health   # Expect: HTTP/2 200 OK

打开此URL，将<your-gonka-cold-address>替换为您的地址:

http://node2.gonka.ai:8000/v2/participants/<your-gonka-cold-address>

您应该会看到JSON格式的参与者数据（participant.address、participant.inferenceUrl、participant.status）。

要检查账户数据（pubkey、balance、denom），请使用:

http://node2.gonka.ai:8000/v2/accounts/<your-gonka-cold-address>

当您的节点完成计算证明阶段（每24小时运行一次）后，您可以访问以下URL查看您的节点:

http://node2.gonka.ai:8000/v1/epochs/current/participants

您可以在MLNode上自行模拟计算证明，以确保在链上开始PoC阶段时一切正常。

您可以在该阶段前关闭服务器，并在下一次计算证明开始前重新启动。要跟踪下一次计算证明会话何时开始，请查看仪表板：

http://node2.gonka.ai:8000/dashboard/gonka/validator

节点运行后，通过代理检查您的节点状态。

curl http://<PUBLIC_IP>:8000/chain-rpc/status

在服务器上，您可以使用私有地址（从容器内部或26657绑定到localhost时）。

curl http://0.0.0.0:26657/status

使用创世节点的公共端点。

curl http://node2.gonka.ai:8000/chain-rpc/status

一旦您的节点在仪表板中可见，您可能还想更新您的公开资料（主机名、网站、头像）。这有助于其他参与者在网络中识别您的节点。您可以在此处找到说明。

为您的账户密钥充值（交易费用）

重要：费用由您的冷钱包支付。请在安全的本地机器上执行转账和收费交易。

从升级v0.2.16开始，Gonka对一组指定的主机交易收取链上费用。仅注册不足以加入计算证明或一个周期：您的冷账户必须持有足够的流动GNK余额，以便这些消息能够被包含在链上。

在下一个PoC窗口前为您的账户密钥地址充值。此余额应与§5 存入抵押品中锁定的抵押品分开——费用从自由余额中扣除；抵押品则存入抵押品模块。

当前费用适用于以下消息类型：

消息	涵盖内容
`MsgPoCV2StoreCommit`	在计算证明期间提交PoC v2提交
`MsgSubmitHardwareDiff`	报告硬件/ML节点变更
`MsgDeclarePoCIntent`	在引导窗口中声明模型意向
`MsgSetPoCDelegation`	将PoC验证权重委托给其他参与者
`MsgRefusePoCDelegation`	明确拒绝某个模型的PoC委托
`MsgDepositCollateral`	存入抵押品（本节的后续步骤）
`MsgWithdrawCollateral`	解绑期后提取抵押品

其他协议职责流量（例如网络视为职责的常规推理和验证路径）不在此费用范围内。始终使用ngonka币种进行余额和费用操作。

在您的本地机器上获取您的冷账户地址:

./inferenced keys show gonka-account-key -a --keyring-backend file

向该地址发送GNK。建议初始充值10 GNK到冷账户——足以支付数个周期的操作费用以及您从冷钱包签署的一次性设置交易（权限授予、委托、抵押品存入）。此外，§3.3 授予权限会创建一个feegrant，允许ML操作密钥从冷钱包支出费用，默认支出限额为10 GNK。此限额是feegrant支出的上限，不会因发送更多GNK而自动补充。抵押品是独立的；请参见§5 存入抵押品。

确认转账已到账（替换<your-gonka-cold-address>）:

curl -s "http://node2.gonka.ai:8000/v2/accounts/<your-gonka-cold-address>" | jq '.balance, .denom'

检查一个周期的费用预算

当您的节点运行且API容器已启动（§4 启动完整节点）后，在服务器上运行此命令。管理API仅监听localhost——不会通过公共代理暴露。

curl -s http://127.0.0.1:9200/admin/v1/epoch-fee-budget | jq

示例响应：

{
  "denom": "ngonka",
  "spendable_balance": "7254963228",
  "budget_balance": "36266880",
  "count": 23712,
  "count_source": "top_participant",
  "budget_known": true,
  "spendable_covers_budget": true
}

如何阅读：

budget_balance — 仅针对当前周期估算所需的ngonka（主要PoC、可能的确认PoC和硬件差异费用）。这是一个包含余量的上限值，而非精确账单。
spendable_balance — 节点当前实际可用于支付费用的金额：冷账户的流动余额，受ML运营密钥剩余费用授权限额的限制。
spendable_covers_budget: true — 该受限金额足以覆盖本周期的估算。
spendable_covers_budget: false — 费用余量不足。请检查两方面：
如果冷账户余额较低 → 向冷账户发送更多GNK。
如果冷账户仍有资金但费用授权限额已用尽 → 撤销并重新授权（见下文）。仅发送GNK不会提高费用授权限额。
count_source: "top_participant" — 该估算基于上一PoC阶段中最活跃参与者的存储提交量。为保守手动估算，请传入您自己的提交数量：

curl -s "http://127.0.0.1:9200/admin/v1/epoch-fee-budget?count=100" | jq

此检查不包括上表中的抵押品或一次性设置消息——仅针对当前周期的重复性PoC/硬件流量。

为多个周期做规划

该端点一次仅估算一个周期。费用在交易落地时消耗；未使用的GNK保留在您的冷账户中，未使用的费用授权余量也保留在授权额度中，直到耗尽。

每个周期重新检查 — 在PoC之前或之后再次运行命令，若网络活动发生变化。
提前规划 — 将budget_balance乘以您希望覆盖的周期数（例如，budget_balance × 90约等于主网三个月，每个周期约24小时）。确保冷账户中保留这么多流动GNK，且费用授权限额足够（默认每个授权为10 GNK）。
当spendable_covers_budget为false时 — 如果余额低则补充冷账户；如果费用授权限额已用尽，则刷新授权（下一节）。没有“补充费用授权”的交易。

当10 GNK授权用尽时刷新费用授权

grant-ml-ops-permissions创建一个费用授权，使ML运营密钥（热）可以从您的账户密钥（冷）支付费用，默认支出限额为10 GNK。Cosmos费用授权没有更新/补充消息：当该授权耗尽（或过期）时，即使冷账户仍有余额，API也无法提交带费用的交易。您必须撤销旧授权，然后重新授权以创建新的10 GNK限额。

确保冷账户仍持有足够的流动GNK（如需则发送更多）。
在您的本地机器上撤销旧授权（[granter] [grantee] — 冷账户，然后热账户）。在运行授权前，请等待撤销交易被确认上链。

./inferenced tx feegrant revoke <cold-account-address> <ml-operational-key-address> \
  --from gonka-account-key \
  --keyring-backend file \
  --node http://node2.gonka.ai:8000/chain-rpc/ \
  --chain-id gonka-mainnet

撤销确认后，重新授权：

./inferenced tx inference grant-ml-ops-permissions \
  gonka-account-key \
  <ml-operational-key-address> \
  --from gonka-account-key \
  --keyring-backend file \
  --gas 2000000 \
  --node http://node2.gonka.ai:8000/chain-rpc/ \
  --chain-id gonka-mainnet

如果已存在授权，grant-ml-ops-permissions将跳过创建新费用授权并提示您撤销。成功重新授权后，使用epoch-fee-budget重新检查，直到spendable_covers_budget为true。

[本地机器] 存入抵押品

重要：请在您创建账户密钥的安全本地机器上执行此步骤。

抵押品是锁定的GNK，用于激活您PoC权重中符合抵押资格的部分。没有它，主机仅能获得基础权重（默认为20%），而无法获得计算证明的全部权重。宽限期已结束，因此必须完成此步骤才能以完整权重运行。

关于时间的说明：验证节点状态确认您的容器正在运行且参与者已注册，但不表示计算证明已成功——PoC每约24小时运行一次，只有在完成之后才能在$NODE_URL/v1/epochs/current/participants看到您的实际权重。以下两种选项允许您要么现在基于估算存入抵押品，要么等待首次PoC完成后再根据精确数据存入。

无法提前知道您的PoC权重——它由您的硬件、网络当前规模和每模型系数决定。

选项A — 现在存入（从周期1起获得完整权重）。 查看网络当前的权重分布，并存入足够覆盖上限的金额。您的节点在首次PoC时已具备抵押品。

export NODE_URL="<seed_api_url from server's config.env>"   # e.g. http://node2.gonka.ai:8000
export CHAIN_ID="gonka-mainnet"

PARAMS=$(curl -s "$NODE_URL/chain-api/productscience/inference/inference/params")
BASE_WEIGHT_RATIO=$(echo "$PARAMS" | jq -r '.params.collateral_params.base_weight_ratio
  | (.value | tonumber) * pow(10; .exponent | tonumber)')
COLLATERAL_PER_UNIT=$(echo "$PARAMS" | jq -r '.params.collateral_params.collateral_per_weight_unit
  | (.value | tonumber) * pow(10; .exponent | tonumber)')

MAX_WEIGHT=$(curl -s "$NODE_URL/v1/epochs/current/participants" \
  | jq '[.active_participants.participants[].weight] | max')

DEPOSIT=$(printf "%.0f" "$(echo "$MAX_WEIGHT * (1 - $BASE_WEIGHT_RATIO) * $COLLATERAL_PER_UNIT * 2" | bc -l)")
echo "Recommended deposit (covers network max with 2x buffer): ${DEPOSIT} ngonka"

公式为MAX_WEIGHT × (1 − BASE_WEIGHT_RATIO) × COLLATERAL_PER_UNIT × 2：仅需为权重中符合抵押资格的部分提供Backing（其余部分作为基础权重授予），而× 2是推荐的安全缓冲。所有参数均从链上读取，因此即使治理更新，脚本仍保持正确。

为何使用2×缓冲？ PoC权重在各周期间波动（网络归一化、模型系数、上限、惩罚）。协议不会自动补充：如果您的抵押品在下一个周期边界时不足以覆盖实际权重，您将无声地获得更低权重，直到您补充更多抵押品——至少损失一个周期的全部奖励。超额抵押品不会丢失：它将保留在模块中，之后可通过withdraw-collateral提取。

选项B — 等待首次PoC，然后精确存入（损失一个周期20%权重）。 现在跳过此步骤，等待首次PoC阶段完成（每约24小时），然后在$NODE_URL/v1/epochs/current/participants查看您的实际权重，并使用您自己的权重替换上述脚本中的MAX_WEIGHT重新运行。从第二个周期开始，您的节点将以完整权重运行。

从您的账户密钥存入抵押品（始终使用ngonka）：

./inferenced tx collateral deposit-collateral ${DEPOSIT}ngonka \
  --from gonka-account-key \
  --keyring-backend file \
  --node $NODE_URL/chain-rpc/ \
  --chain-id $CHAIN_ID

验证：

MY_ADDR=$(./inferenced keys show gonka-account-key -a --keyring-backend file)
curl -s "$NODE_URL/chain-api/productscience/inference/collateral/collateral/$MY_ADDR" | jq

存款是累积的——如果您的权重增长，可稍后通过另一次deposit-collateral补充。要释放未使用的抵押品，请使用withdraw-collateral（需经历解绑期，默认1个周期）。

有关 slashing、提取和参数调优的详细信息，请参阅抵押品文档。

可选：PoC委托与拒绝

在您的主机已注册、ML运营密钥已授权、且您能验证参与后使用本节——通常在您的本地机器上使用账户（冷）密钥（gonka-account-key）。此处操作不是启动容器所必需的；当您不在自己的GPU上运行每个治理批准的模型，而必须委托PoC投票给其他参与者、拒绝委托或与params比较时间时适用。

对于每个model_id，您要么运行模型（从您的堆栈提交PoC），要么在链上发出信号。委托是当您信任运行该模型的主机时的常见选择；拒绝是明确的退出。背景：多模型PoC——主机操作指南。

将NODE设置为任意同步的链RPC（模式与grant-ml-ops-permissions相同：从config.env获取API URL并附加/chain-rpc/）。

export NODE="<PUBLIC_CHAIN_RPC>"   # e.g. http://node2.gonka.ai:8000/chain-rpc/
export CHAIN_ID="gonka-mainnet"
export KEY="gonka-account-key"
export KEYRING_BACKEND="file"

检查治理参数（惩罚、penalty_start_epoch等）：

./inferenced query inference params --node "$NODE" -o json

检查您的PoC委托/拒绝/意图状态（所有模型）：

MY_ADDR="$(./inferenced keys show "$KEY" -a --keyring-backend "$KEYRING_BACKEND")"
./inferenced query inference poc-delegation "$MY_ADDR" --node "$NODE" -o json

委托 — 将您对该模型PoC验证的权重附加到 DELEGATEE（其 gonka1… 地址）。以MiniMax为例：

MODEL="MiniMaxAI/MiniMax-M2.7"
DELEGATEE="gonka1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

./inferenced tx inference set-poc-delegation "$MODEL" "$DELEGATEE" \
  --from "$KEY" \
  --node "$NODE" \
  --chain-id "$CHAIN_ID" \
  --keyring-backend "$KEYRING_BACKEND" \
  --gas auto \
  --gas-adjustment 1.3 \
  -y

以DeepSeek为例（例如您仅在自己的GPU上运行MiniMax）：

MODEL="deepseek-ai/DeepSeek-V4-Flash-0731"
DELEGATEE="gonka1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

./inferenced tx inference set-poc-delegation "$MODEL" "$DELEGATEE" \
  --from "$KEY" \
  --node "$NODE" \
  --chain-id "$CHAIN_ID" \
  --keyring-backend "$KEYRING_BACKEND" \
  --gas auto \
  --gas-adjustment 1.3 \
  -y

清除对某个模型的委托：

MODEL="deepseek-ai/DeepSeek-V4-Flash-0731"

./inferenced tx inference set-poc-delegation "$MODEL" "" \
  --from "$KEY" \
  --node "$NODE" \
  --chain-id "$CHAIN_ID" \
  --keyring-backend "$KEYRING_BACKEND" \
  --gas auto \
  --gas-adjustment 1.3 \
  -y

拒绝对某个模型的委托（链上明确的“否”）。对于您未运行的合格模型，请使用此操作（例如，若您仅提供MiniMax服务，则拒绝GLM-5.3-Flash或DeepSeek）。常规拒绝/缺席惩罚仅适用于合格组。

MODEL="deepseek-ai/DeepSeek-V4-Flash-0731"

./inferenced tx inference refuse-poc-delegation "$MODEL" \
  --from "$KEY" \
  --node "$NODE" \
  --chain-id "$CHAIN_ID" \
  --keyring-backend "$KEYRING_BACKEND" \
  --gas auto \
  --gas-adjustment 1.3 \
  -y

declare-poc-intent 主要适用于新模型启动窗口；请参阅 GLM-5.3-Flash 启动和 DeepSeek V4 Flash 启动。更多命令和边缘情况：多模型PoC — 主机操作指南。

停止并清理您的节点

如何停止您的节点

检查您当前所处的纪元。打开以下URL：http://node1.gonka.ai:8000/api/v1/epochs/latest（您也可使用任何其他活跃参与者的URL）。

在响应中查找：

"latest_epoch": {
    "index": 88,
    ...
}

记录您的节点最后参与的纪元索引。

在同一JSON响应中查找：

"next_epoch_stages": {
  ...
  "claim_money": <block_number>
}

该区块编号表示您可领取奖励的区块之后。但请注意，您现在应立即禁用每个ML节点（无需等待该区块到来再禁用ML节点）。

禁用每个ML节点。

curl -X POST http://<api_node_static_ip>:<admin_port>/admin/v1/nodes/<id>/disable

等待下一个纪元。请勿立即停止网络节点或ML节点。禁用标志仅在下一个纪元开始后生效。

保持网络节点在线并同步，它应自动处理奖励领取。要检查您的最新奖励是否已被领取，在 claim_money 区块之后运行以下命令（请将 <YOUR_ADDRESS> 和 <EPOCH> 替换为您的实际值）：

inferenced query inference show-epoch-performance-summary <EPOCH> <YOUR_ADDRESS> --node http://node1.gonka.ai:8000/chain-rpc/ --output json

示例：

Output:
{
  "epochPerformanceSummary": {
    "epoch_index": "87",
    "participant_id": "<YOUR_ADDRESS>",
    "missed_requests": "1",
    "rewarded_coins": "123456",
    "claimed": true
  }
}

如果结果为 claimed = true，则您的奖励已被领取。如果结果为 false，请继续执行手动领取步骤。

手动领取奖励（如需要）

运行：

curl -X POST http://localhost:9200/admin/v1/claim-reward/recover \
 -H "Content-Type: application/json" \
 -d '{"force_claim": true}'

验证移除和权重。如果您禁用了所有节点，则您的参与者应不再出现在活跃参与者列表中。若您仍能看到自己的参与者，说明网络仍期望您参与该纪元，若此时禁用节点，您可能会错过推理，从而影响您的声誉。

确保您位于 gonka/deploy/join 文件夹中。要停止所有运行的容器：

docker compose -f docker-compose.yml -f docker-compose.mlnode.yml down

此操作将停止并移除 docker-compose.yml 和 docker-compose.mlnode.yml 文件中定义的所有服务，除非明确配置，否则不会删除卷或数据。

如何彻底清理您的节点（完全重置）

如果您想完全重置节点并删除所有数据（用于重新部署或迁移），请使用以下清理步骤。

为清除缓存并从头开始，删除本地 .inference 和 .dapi 文件夹（推理运行时缓存和身份）：
```
rm -rf .inference .dapi .tmkms
```
(可选) 清除模型权重缓存：
```
rm -rf $HF_HOME
```

Note

删除 $HF_HOME 将需要重新从Hugging Face下载大型模型文件，或重新挂载NFS缓存。

需要帮助？ 请访问常见问题页面获取答案，或加入 Discord服务器获取一般咨询、技术问题或安全问题的帮助。