设置您的节点

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

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

网络节点 – 由两个节点组成的服务：一个链节点和一个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 — 基础模型，同时也是网络上的活跃PoC模型
`moonshotai/Kimi-K2.6`	Kimi K2.6 — 活跃PoC模型
`deepseek-ai/DeepSeek-V4-Flash-0731`	DeepSeek V4 Flash — 活跃PoC模型（周期360；系数0.214）

权威模型列表（治理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节点运行一个模型。主机可以为MiniMax、Kimi和DeepSeek分别运行独立的ML节点（或集群）。

仓库中的参考部署配置

DeepSeek V4 Flash配置、MiniMax minimaxm27-* 配置和MLNode 3.0.16 位于 vllm-0.25.1-upgrade 分支上（非 main）。将与您的硬件匹配的文件复制到 node-config.json，而不是从头编写：

Kimi K2.6 — deploy/join/node-config-kimik26-H200.json, deploy/join/node-config-kimik26-B200.json
MiniMax M2.7 — deploy/join/node-config-minimaxm27-A100.json, deploy/join/node-config-minimaxm27-H100.json, deploy/join/node-config-minimaxm27-H200.json, deploy/join/node-config-minimaxm27-B200.json, deploy/join/node-config-minimaxm27-B300.json
DeepSeek V4 Flash — deploy/join/node-config-deepseekv4flash0731-H100.json, deploy/join/node-config-deepseekv4flash0731-H200.json, deploy/join/node-config-deepseekv4flash0731-B200.json, deploy/join/node-config-deepseekv4flash0731-B300.json。在Blackwell上，nvfp4变体：node-config-deepseekv4flash0731-B200-nvfp4.json, node-config-deepseekv4flash0731-B300-nvfp4.json。

为方便起见，以下内联复制了这些文件的内容。

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

多模型PoC按每个模型跟踪参与情况。如果您的硬件未覆盖所有治理批准的模型，您需要进行链上委托或拒绝，以便为跳过的模型正确处理共识权重。这不是启动节点所必需的 — 您使用与为ML操作密钥授予权限中相同的账户（冷）密钥，在注册和验证之后。末尾提供了复制粘贴命令：可选：PoC委托和拒绝。有关策略和惩罚，请阅读多模型PoC — 主机操作指南。

治理与模型分类

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

建议的硬件配置

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

模型名称	ML节点（最少）	示例硬件	每个ML节点的最小VRAM
`moonshotai/Kimi-K2.6`	≥ 2	每个MLNode配备8×H200或8×B200（参考架构）	720 GB
`MiniMaxAI/MiniMax-M2.7`	≥ 2	每个MLNode配备4×A100 / 4×H100 / 2×H200 / 2×B200	~320 GB
`deepseek-ai/DeepSeek-V4-Flash-0731`	≥ 2	每个MLNode配备4×H100 / 2×H200 / 2×B200 / 1×B300	~280 GB

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

每个模型的weight_scale_factor值由治理设定。DeepSeek V4 Flash当前使用0.214；在B300上这是权重最高的选项，而MiniMax在H100/H200上权重最高，Kimi在B200上权重最高。参见DeepSeek V4 Flash引导和系数表。示例vLLM参数见下方node-config.json示例。

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

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

16核CPU（amd64）
64 GB及以上内存
1TB NVMe SSD
至少100Mbps网络连接（推荐1Gbps）

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

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

至少为GPU显存容量1.5倍的内存
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 标签）。

并复制 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) 转到个人资料 → API 令牌。

3) 点击创建令牌。

4) 使用编辑区域 DNS 模板，或设置权限：区域：读取和 DNS：编辑。

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 和管理员 → 服务账号 → 创建服务账号（例如 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 → 令牌。

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

Hetzner DNS

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

2) 转到 API 令牌。

3) 创建新令牌并设置 HETZNER_API_KEY。

加载配置：

source config.env

使用环境变量

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

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

Note

当前网络支持三种活跃的PoC模型：MiniMaxAI/MiniMax-M2.7（基础）、moonshotai/Kimi-K2.6 和 deepseek-ai/DeepSeek-V4-Flash-0731。请选择与您将要部署的模型和GPU类别匹配的标签。治理机制负责决定添加或修改支持的模型。有关模型治理的工作原理及如何提议新模型的详细信息，请参阅交易与治理指南。

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

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

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

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", "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 引导。

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/docker-compose.mlnode.yml 中预设）。

仓库中的参考部署配置：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

在 4×H100 上使用此 vLLM 参数集运行 MiniMax M2.7。采用 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

在 2×H200 上使用此 vLLM 参数集运行 MiniMax M2.7（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

在 2×B200 上使用此 vLLM 参数集运行 MiniMax M2.7（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

在 4×H100 上使用此 vLLM 参数集运行 DeepSeek V4 Flash。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

在 2×H200 上使用此 vLLM 参数集运行 DeepSeek V4 Flash。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

在 2×B200 上使用此 vLLM 参数集运行 DeepSeek V4 Flash。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

在 1×B300 上使用此 vLLM 参数集运行 DeepSeek V4 Flash。DeepSeek 需要 MLNode 3.0.16（vLLM 0.25.1）。在 B300 上，这是当前系数（0.214）下权重最高的 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"
                    ]
                }
            }
        }
    ]
    ```

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

Validate the deployment

gonka 仓库提供了一个代理技能 mlnode-validate，用于根据特定模型的预计算诚实 PoC 向量验证 ML Node。当前仓库中已提交的黄金参考包括 Qwen3-0.6B、Qwen3-235B（默认 + DeepGEMM）、Kimi K2.6 和 DeepSeek V4 Flash（deepseek-ai-deepseek-v4-flash-0731.json 在 vllm-0.25.1-upgrade 上）。请参阅验证 ML Node 部署。

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

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

Kimi K2.6MiniMax M2.7DeepSeek V4 Flash

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

模型许可证：请参阅模型许可证。有关操作说明和链上选项（意图、委托），请参阅 Kimi K2.6 启动。

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 —— 请参见网络更新。

Launch Nodes

[服务器] 拉取 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 keyring 后端创建热密钥（程序访问所必需）。密钥将存储在映射到容器 /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 运营密钥：

./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

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

[本地机器] 存入抵押品

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

抵押品是锁定的GNK，用于激活您计算证明权重中符合抵押资格的部分。如果没有它，主机仅能获得默认的基础权重（20%）。宽限期已结束，因此此步骤是实现满额权重所必需的。

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

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

选项A — 现在存入（从第1个周期起获得满额权重）。 查看网络中的当前权重分布，并存入足以覆盖上限的金额。您的节点在首次计算证明时已具备抵押品。

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：仅需为权重中符合抵押资格的部分提供担保（其余部分作为基础权重授予），而× 2是建议的安全缓冲。所有参数均从链上读取，因此若治理更新，脚本仍保持正确。

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

选项B — 等待首次计算证明，再精确存入（损失一个周期20%权重）。 现在跳过此步骤，等待您的首次计算证明阶段完成（每约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、提取和参数调优的详细信息，请参阅抵押品文档。

可选：计算证明委托与拒绝

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

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

将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

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

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

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

MODEL="moonshotai/Kimi-K2.6"
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

以MiniMax为例（例如，您仅在GPU上运行Kimi）：

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或Kimi）：

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="moonshotai/Kimi-K2.6"

./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

拒绝某个模型的委托（链上明确的“否”）：

MODEL="moonshotai/Kimi-K2.6"

./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主要适用于新模型启动窗口；请参阅Kimi K2.6启动和DeepSeek V4 Flash启动。更多命令和边缘情况：多模型计算证明——主机操作指南。

停止并清理您的节点

如何停止您的节点

检查您当前所处的周期。打开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，请进入手动领取步骤。

!!! note 手动领取奖励（如需）运行：

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 服务器获取一般查询、技术问题或安全问题的帮助。