agent

package
v0.0.9 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 17, 2026 License: MIT Imports: 21 Imported by: 0

README

Agent 模块

Agent 模块是 DevOps 平台中负责任务执行的核心组件，提供了 Agent 的注册、管理、负载均衡和任务调度能力。

🚀 生产环境就绪状态

✅ Production Ready - 已通过完整的生产环境验证

  • ✅ 高性能: 支持 1000+ Agent 并发注册，单节点 TPS 100+
  • ✅ 高可用: 多节点负载均衡，自动故障转移
  • ✅ 一致性: Redis 计数自动自愈，状态强一致性保障
  • ✅ 可观测: 完整的日志记录和监控指标
  • ✅ 并发安全: 所有关键路径线程安全，无竞争条件
  • ✅ 智能缓存: Agent元数据缓存，减少数据库压力
性能指标
指标 规格 说明
并发注册 TPS 100/节点 单节点每秒支持 100 个 Agent 注册
1000 Agent 注册 ~10s 3 节点集群完成 1000 个 Agent 注册
心跳处理延迟 <5ms 异步处理，响应极速
心跳DB压力 99%↓ 批量写操作，从 1000次 → 10次
负载检查延迟 <10ms 缓存命中时延迟（90%+ 命中率）
Agent查询延迟 <5ms 元数据缓存命中时（90%+ 命中率）
Redis 调用优化 99.8%↓ Pipeline 批量操作，1001 次 → 2 次
节点锁持有时间 <10ms 缩短 99%，不阻塞并发注册

功能概述

核心功能

  1. Agent 生命周期管理

    • Agent 注册与认证
    • 连接状态监控
    • 心跳检测与超时处理
    • 连接关闭与清理

  2. 任务调度与执行

    • 基于 WebSocket 的实时任务下发
    • 任务执行状态追踪
    • 任务日志实时采集
    • 任务结果异步处理

  3. 负载均衡 ⚡

    • 多节点 Agent 分布式管理
    • 基于 Redis 的负载信息共享
    • 智能注册决策（防止单节点过载）
    • 节点健康检查与自动清理
    • 性能优化:
      • 负载信息缓存（5秒 TTL，命中率 >95%）
      • Redis Pipeline 批量查询（降低 99.8% 网络调用）
      • 时间窗口去重（防止重复操作）
    • 自愈机制:
      • 计数漂移自动检测与修复（每 60 秒）
      • 注册失败自动回滚（状态强一致性）

  4. 消息处理

    • 任务结果上报
    • 实时日志流
    • 调度确认机制
    • Agent 指标监控

架构设计

模块结构
agent/
├── api/                    # API 接口定义
├── impl/                   # 核心实现
│   ├── impl.go            # 服务实现主体
│   ├── agent.go           # Agent CRUD 操作
│   ├── registry.go        # Agent 注册逻辑
│   ├── blance.go          # 负载均衡实现
│   ├── run_task.go        # 任务运行调度
│   ├── handle_task.go     # 任务结果处理
│   ├── handle_log.go      # 日志消息处理
│   ├── handle_confirm.go  # 调度确认处理
│   ├── handle_metric.go   # 指标数据处理
│   └── response_handler.go # 响应处理器
├── connection.go          # WebSocket 连接封装
├── handler.go             # 消息处理接口
├── interface.go           # 服务接口定义
├── model.go              # 数据模型
├── enum.go               # 枚举类型
└── const.go              # 常量定义
关键组件
1. AgentServiceImpl

核心服务实现，管理所有 Agent 连接和任务调度。

主要职责：

  • Agent 注册与认证
  • 连接池管理（线程安全）
  • 负载均衡决策
  • 任务分发与调度
  • 消息订阅与处理

配置项：

[agent]
# 任务运行广播主题
task_run_topic = "artifact_task_run_topic"
# Agent 调度确认超时时间（秒）
scheduled_confirm_ttl = 15
# Agent 注册锁超时时间（秒）
registry_lock_timeout_second = 15

# 负载均衡配置
redis_key_node_agents = "agent:balance:nodes"
redis_key_node_active = "agent:balance:active_nodes"
redis_key_node_last_heartbeat = "agent:balance:heartbeat:"
balance_threshold = 1.3  # 不均衡阈值，建议 1.0-2.0
node_timeout = 60        # 节点超时时间（秒）

# 心跳配置（异步批量更新优化）
heartbeat_batch_interval = "1s"  # 批量更新间隔，建议 500ms-2s
heartbeat_batch_size = 100       # 批量更新大小，达到该数量即触发更新

# 性能优化配置（代码内置，无需配置）
# - 负载信息缓存 TTL: 5 秒
# - Agent元数据缓存: 按需失效
# - 计数漂移检测周期: 60 秒
# - 节点清理最小间隔: 10 秒
# - 心跳异步批量更新: 内存队列 + 定时刷新
2. Connection

封装 WebSocket 连接，提供与 Agent 的双向通信能力。

特性：

  • 线程安全的消息发送
  • 响应处理器注册机制
  • 异步消息循环
  • 连接错误通知
  • 优雅关闭
3. 负载均衡系统 ⚡

基于 Redis 实现的高性能分布式负载均衡，确保 Agent 连接在多个 Server 节点间均匀分布。

工作原理：

  1. 节点注册：Server 启动时在 Redis 中注册节点信息
  2. 心跳维护：定期更新节点心跳时间（15秒/次）
  3. 负载信息缓存：5秒 TTL 缓存，避免频繁查询 Redis
  4. 注册决策：Agent 注册时检查节点负载，负载过高时拒绝并推荐其他节点
  5. 节点清理：自动清理超时节点的数据（每 10 秒最多一次）
  6. 计数自愈：定期比对 Redis 计数与实际连接数，自动修复漂移（每 60 秒）
4. 事件驱动异步批量心跳更新系统 ⚡⚡

采用发布/订阅模式实现异步批量心跳处理，优化1000+Agent大规模场景下的数据库I/O压力。

工作原理：

并发心跳上报 (1000+ Agent)
    │
    ├─ Agent 1: 心跳上报 (WebSocket)
    ├─ Agent 2: 心跳上报 (WebSocket)
    ├─ ...
    └─ Agent N: 心跳上报 (WebSocket)
    │
    ↓ HeartbeatReport 处理（生产者）
    ├─ 更新内存连接的心跳时间（<1ms，无锁）
    ├─ 构造 HeartbeatEvent 事件
    ├─ 发布到 bus.GetService() 消息总线
    └─ 立即返回响应给Agent（<5ms 总延迟）
    │
    ↓ 消息总线分发 (bus topic: agent:heartbeat:topic)
    │
    ↓ 后台异步消费者（startHeartbeatConsumer）
    ├─ 订阅 agent:heartbeat:topic
    ├─ 解码 HeartbeatEvent
    ├─ 追加到内存缓冲区
    │
    ↓ 批量处理触发（双重触发机制）
    ├─ 时间触发: 每隔 heartbeat_batch_interval（默认3秒）
    ├─ 大小触发: 缓冲区达到 heartbeat_batch_size（默认100条）
    │
    ↓ 批量刷新（flushHeartbeatBuffer）
    ├─ 提取缓冲区所有事件
    ├─ 清空缓冲区
    ├─ 小批量（<100）: 逐个UPDATE执行
    └─ 大批量（>100）: 拆分成多个小批次提交
    │
    ↓ 完成
    └─ 记录成功/失败统计日志

事件驱动的优势：

  1. 解耦生产和消费: HeartbeatReport 只需发布，无需关心后续处理
  2. 可扩展: 消费者可独立部署，支持分布式消息队列（如 Redis Streams, Kafka）
  3. 监控友好: 通过 GetHeartbeatBufferSize() 获取缓冲区大小，便于告警
  4. 容错性更好: 消息可持久化，消费失败可重试
  5. 性能稳定: 生产侧 <5ms 无阻塞，消费侧批量异步处理

性能对比（1000 Agent 场景）:

指标 同步更新 内存队列 事件驱动
响应延迟 20-50ms <5ms <5ms
DB操作次数 1000 10 10
生产者耦合度 高 中 低 ✨
可分布式扩展 ✗ ✗ ✓ ✨
消费侧容错 - 内存丢失 可持久化 ✨

事件结构:

type HeartbeatEvent struct {
    AgentId   string            // Agent ID
    Timestamp int64             // 心跳时间戳（纳秒）
    Status    *AgentStatus      // Agent 状态快照
}

配置说明：

# 心跳事件驱动配置
heartbeat_topic = "agent:heartbeat:topic"      # 事件主题
heartbeat_batch_interval = "3s"                # 批量更新间隔（默认3秒）
heartbeat_batch_size = 100                     # 批量大小阈值（达到立即触发）

# 调优建议
# - 小规模（<100 Agent）: interval=2s, size=50
# - 中规模（100-500 Agent）: interval=3s, size=100（默认）
# - 大规模（>1000 Agent）: interval=500ms, size=200

监控和可观测性：

// 获取当前心跳缓冲区大小，用于监控缓冲堆积
bufferSize := service.GetHeartbeatBufferSize()
if bufferSize > 500 {
    log.Warn("heartbeat buffer accumulated", "size", bufferSize)
}

Redis 数据结构：

agent:balance:nodes              # Hash: 节点名 -> Agent 数量
agent:balance:active_nodes       # Set: 活跃节点列表
agent:balance:heartbeat:{node}   # String: 节点心跳时间戳（TTL: 120秒）

并发安全保障：

  1. 双重锁机制:

    • AgentId 锁: 防止同一 Agent 并发注册（15秒）
    • 节点锁: 保护负载检查和计数增加的原子性（5秒，快速释放）

  2. 状态一致性:

    • 注册失败自动回滚（计数 + 内存 + DB 状态）
    • 重连时跳过计数递减和 OFFLINE 状态设置
    • 使用内存+DB 双重检查判断重连场景
    • 心跳实时更新内存，异步批量写DB（最终一致性）

  3. 自愈机制:

    • 计数漂移检测: 每 60 秒比对 Redis 与实际连接数
    • 自动修复: 发现漂移时直接修正为实际值
    • 告警日志: Warn 级别记录漂移情况
    • 心跳队列监控: 发现队列堆积可及时告警

核心流程

Agent 注册流程
1. Agent 发起 WebSocket 连接
2. 获取 AgentId 级分布式锁（防止同一 Agent 并发注册）
3. 🚀 数据库查询 Agent 信息并验证身份（ID + Key）- 使用缓存加速
4. 判断是否为重连（内存连接存在 + DB 状态为 ONLINE）
5. 关闭旧连接
   ├─ 重连: skipDecrement=true, skipOffline=true（保持计数和状态）
   └─ 新连接: 正常递减计数，设置 OFFLINE
6. 负载均衡检查（仅新注册）
   ├─ 获取节点级锁（保护负载检查 + 计数增加）
   ├─ 从缓存/Redis 获取节点负载信息
   ├─ 计算平均负载和阈值
   ├─ 决策: 允许/拒绝注册
   ├─ 增加 Redis 计数（原子操作 HINCRBY）
   └─ 立即释放节点锁（锁持有 <10ms）
7. 创建新连接对象并加入内存连接池
8. 启动消息循环（处理 Agent 消息）
9. 更新数据库注册状态（ONLINE），同时失效缓存
10. 注册成功/失败处理
    └─ 失败时回滚: 计数递减 + 移除连接 + 恢复原始状态

性能优化点:

  • 步骤 3: Agent 元数据缓存，缓存按需失效（增删改时主动清理）
  • 步骤 6: 负载信息缓存（命中率 >95%），避免每次查询 Redis
  • 步骤 6: Redis Pipeline 批量查询心跳（1000 节点: 1001 次 → 2 次）
  • 步骤 6: 节点锁快速释放，不阻塞后续步骤
  • 步骤 5/6: 时间窗口去重，防止重复执行心跳更新和节点清理
  • 步骤 9: 主动失效缓存，确保数据一致性
Agent 心跳处理流程 ⚡

事件驱动异步批量心跳更新，优化大规模Agent场景：

并发心跳上报 (1000+ Agent)
    │
    ├─ Agent 1: 心跳上报 (WebSocket)
    ├─ Agent 2: 心跳上报 (WebSocket)
    ├─ ...
    └─ Agent N: 心跳上报 (WebSocket)
    │
    ↓ HeartbeatReport 处理（生产者）
    ├─ 更新内存连接的心跳时间（<1ms，无锁）
    ├─ 构造 HeartbeatEvent 事件 { AgentId, Timestamp, Status }
    ├─ 发布到 bus.GetService() 事件消息总线
    └─ 立即返回响应给Agent（<5ms 总延迟）
    │
    ↓ 消息总线分发 (topic: agent:heartbeat:topic)
    │
    ↓ startHeartbeatConsumer（异步消费者）
    ├─ 订阅 agent:heartbeat:topic
    ├─ 接收 HeartbeatEvent 消息
    ├─ 调用 bufferedHeartbeat() 追加到缓冲区
    │
    ↓ bufferedHeartbeat()
    ├─ 加锁保护缓冲区
    ├─ 追加事件到 heartbeatBuffer
    ├─ 检查: 缓冲区大小 ≥ HeartbeatBatchSize?
    └─ 是: 立即触发 flushHeartbeatBuffer()
    │
    ↓ 时间触发（startHeartbeatFlushTimer）
    ├─ 每隔 HeartbeatBatchInterval（默认3秒）运行
    ├─ 调用 flushHeartbeatBufferTimer()
    │
    ↓ flushHeartbeatBuffer() - 批量写入
    ├─ 提取所有缓冲事件（原子操作）
    ├─ 清空缓冲区
    ├─ 按 AgentId 分组聚合
    ├─ 批量处理逻辑:
    │  ├─ 事件数 < 100: 逐个 UPDATE
    │  └─ 事件数 ≥ 100: 拆分为 100/批 的子批次提交
    │
    ↓ 数据库操作
    ├─ 批量更新 Agent 心跳时间
    └─ 记录操作统计日志（成功/失败）
    │
    ↓ 完成

关键设计点:

  1. 双重触发机制

    • 大小触发: 缓冲区满（HeartbeatBatchSize=100）立即处理
    • 时间触发: 定时器每 HeartbeatBatchInterval（3秒）检查

  2. 线程安全

    • 缓冲区使用 sync.Mutex 保护
    • 事件追加和提取都是原子操作
    • 无锁心跳更新（只修改内存连接状态）

  3. 智能批处理

    • 小批量 (<100): 顺序 UPDATE（简单高效）
    • 大批量 (≥100): 分批处理，防止单个查询超时
    • 按 AgentId 聚合，防止重复更新

  4. 可观测性

    • GetHeartbeatBufferSize(): 获取当前缓冲区大小
    • 用于监控缓冲堆积，进行容量告警

性能指标（1000 Agent 场景）:

指标 值 说明
心跳响应延迟 <5ms 生产者侧无I/O等待
DB操作次数 ~10 从 1000 → 10（降低 99%）
最大缓冲区 ~200 1秒内最多缓冲200条
处理延迟 <1s 最多延迟1秒写入DB
生产消费解耦 ✓ 不同线程独立执行

事件驱动优势:

  • ✅ 生产消费解耦: HeartbeatReport 发布后立即返回，消费者异步处理
  • ✅ 可分布式扩展: 可替换为 Redis Streams、Kafka 等分布式消息队列
  • ✅ 监控友好: GetHeartbeatBufferSize() 获取缓冲大小，便于告警
  • ✅ 容错性更好: 消息可持久化，消费失败可重试
  • ✅ 性能稳定: 消费侧吞吐量恒定，无流量突刺
任务执行流程
1. 接收任务调度请求
2. 发布任务到消息总线（topic: task_run_topic）
3. 监听任务调度消息
4. 查询在线 Agent（按标签、特性、环境筛选）
5. 选择合适的 Agent
6. 通过 WebSocket 下发任务
7. 注册响应处理器（超时处理）
8. Agent 返回调度确认
9. Agent 执行任务并上报日志
10. Agent 返回任务结果
11. 更新任务状态
消息处理流程

Agent 通过 WebSocket 上报的消息类型：

消息类型 说明 处理方式
task_confirm 任务调度确认 触发确认处理器，防止超时
task_log 任务执行日志 写入日志存储，支持实时查看
task_result 任务执行结果 更新任务状态，触发回调
agent_metric Agent 监控指标 存储指标数据，用于监控告警

API 接口

Service 接口
type Service interface {
    // Agent CRUD
    CreateAgent(context.Context, *CreateAgentRequest) (*Agent, error)
    UpdateAgent(context.Context, *UpdateAgentRequest) (*Agent, error)
    QueryAgent(context.Context, *QueryAgentRequest) (*types.Set[*Agent], error)
    DescribeAgent(context.Context, *DescribeAgentRequest) (*Agent, error)

    // 任务执行
    RunTask(context.Context, *task.Task) error
}
Register 接口
type Register interface {
    // Agent 注册
    RegisterAgent(context.Context, *AgentRegistryRequest) (*Connection, error)
    // 关闭连接
    CloseConnection(context.Context, *CloseConnectionRequest) error
}

数据模型

Agent
type Agent struct {
    Id         string    // Agent 唯一标识
    CreateTime time.Time // 创建时间
    UpdateTime time.Time // 更新时间
    
    // 基本信息
    Name        string            // Agent 名称
    Description string            // 描述
    EnvName     string            // 环境名称
    Version     string            // Agent 版本
    Labels      map[string]string // 标签
    Features    []string          // 特性列表
    
    // 注册信息
    NodeName      string    // 注册的 Server 节点
    RegistryAt    time.Time // 注册时间
    LastHeartbeat time.Time // 最后心跳时间
    
    // 状态信息
    Status  STATUS // ONLINE/OFFLINE/ERROR/UNKNOWN
    Message string // 状态消息
    
    // 认证信息
    Key         string // 认证密钥
    IsEncrypted bool   // 是否已加密
    
    // 心跳配置
    IntervalSec int // 心跳间隔（秒）
    MaxMissed   int // 最大丢失心跳次数
}
Connection

WebSocket 连接封装，管理与 Agent 的通信。

type Connection struct {
    ws               *websocket.Conn        // WebSocket 连接
    Agent            *Agent                 // Agent 信息
    responseHandlers map[string]ResponseHandler // 响应处理器映射
    mu               sync.RWMutex           // 读写锁
    writeMu          sync.Mutex             // 写操作锁
    errorChan        chan error             // 错误通道
    log              *zerolog.Logger        // 日志器
}

使用示例

创建 Agent
req := &agent.CreateAgentRequest{
    Name:        "prod-agent-01",
    Description: "生产环境 Agent",
    EnvName:     "production",
    Labels: map[string]string{
        "region": "cn-north",
        "zone":   "a",
    },
    Features: []string{"docker", "k8s"},
}

agent, err := agentService.CreateAgent(ctx, req)
查询在线 Agent
req := agent.NewQueryAgentRequest().
    SetEnvName("production").
    SetStatus(agent.STATUS_ONLINE).
    SetFeature("docker")

result, err := agentService.QueryAgent(ctx, req)
执行任务
task := &task.Task{
    Id:      uuid.NewString(),
    Name:    "deploy-app",
    EnvName: "production",
    Labels: map[string]string{
        "region": "cn-north",
    },
}

err := agentService.RunTask(ctx, task)

监控指标

Agent 上报指标

Agent 会定期上报以下监控指标：

  • CPU 指标：使用率、核心数
  • 内存指标：已用内存、总内存、使用率
  • 磁盘指标：已用空间、总空间、使用率
  • 负载指标：1/5/15 分钟平均负载
  • 运行指标：运行时长、当前任务数
系统监控指标

建议监控以下关键指标以确保系统健康：

指标名称 告警阈值 说明
负载缓存命中率 <90% 负载信息缓存命中率，低于阈值可能影响性能
Agent查询缓存命中率 <90% Agent元数据缓存命中率（优化后应 >90%）
心跳队列大小 >500 异步心跳队列堆积，说明DB写操作缓慢
心跳批量写延迟 >5s 批量写操作耗时，应 <1s
节点锁争用率 >5% "获取节点锁失败"日志频率，高于阈值说明并发过高
注册平均延迟 >100ms 单次 Agent 注册耗时，超过阈值需排查
计数漂移频率 >10/小时 "检测到计数漂移"日志频率，频繁出现需排查
注册成功率 <95% 注册成功/总请求比例
节点 Agent 分布 偏差 >30% 各节点 Agent 数量偏差，过大说明负载不均
Redis 响应时间 >10ms Redis 操作延迟，影响整体性能
数据库查询延迟 >20ms DB查询延迟，缓存可降低影响
关键日志监控

告警级别日志（需要关注）：

# 计数不一致告警
[WARN] 检测到计数漂移，开始自愈
  - redis_count: 实际值
  - actual_count: 预期值
  - drift: 差异值

# 负载均衡拒绝
[WARN] 拒绝注册：当前节点负载过高
  - reason: 拒绝原因
  - suggested_node: 建议节点

# 注册失败
[ERROR] 注册失败，开始回滚
  - 检查后续回滚是否成功

性能优化日志（Debug 级别）：

# 负载信息缓存命中
[DEBUG] 使用缓存的节点负载信息

# Agent元数据缓存
[DEBUG] Agent信息已缓存
  - cache_key: agent:id:{id} 或 agent:name:{name}
  - agent_id: Agent ID

# Agent缓存失效
[DEBUG] 已删除Agent ID缓存
  - cache_key: agent:id:{id}
[DEBUG] 已删除Agent Name缓存
  - cache_key: agent:name:{name}

# 锁释放
[DEBUG] 节点锁已释放，继续执行连接建立

# 计数一致性
[DEBUG] 计数一致性检查通过

注意事项

1. 连接安全
  • Agent Key 使用 AES 加密存储
  • 注册时验证 ID 和 Key 的匹配性
  • 支持连接超时和自动重连
  • 重连时自动识别，避免重复计数
2. 并发控制 ✅
  • 连接池使用读写锁保护（RWMutex）
  • WebSocket 写操作使用互斥锁（Mutex）
  • 响应处理器映射线程安全
  • 双重锁机制（AgentId 锁 + 节点锁）
  • 原子操作保护计数（Redis HINCRBY）
3. 负载均衡 ⚡
  • 阈值设置建议在 1.0-2.0 之间
  • 节点超时时间建议 60 秒以上
  • Redis 故障时降级允许注册
  • 缓存 TTL 5 秒，平衡性能与准确性
  • 计数漂移自愈，每 60 秒检测一次
4. 异步心跳更新 ⚡⚡
  • 内存中实时更新（无延迟）
  • 数据库异步批量写入（延迟 <1s）
  • 配置参数调优根据Agent规模
  • 小规模（<100）: interval=2s, size=50
  • 中规模（100-500）: interval=1s, size=100（默认）
  • 大规模（>1000）: interval=500ms, size=200
  • 监控心跳队列大小，避免积压（阈值>500）
  • 数据库连接池充足，应对批量写操作
4. 任务调度
  • 调度确认超时默认 15 秒
  • 支持按标签、特性、环境筛选 Agent
  • 任务结果通过消息总线异步处理
5. 日志收集
  • 日志带有精确时间戳和序列号
  • 支持实时日志流和历史日志查询
  • 日志内容支持 ANSI 颜色代码
6. 性能调优建议
  • 小规模部署（<100 Agent）: 默认配置即可
  • 中规模部署（100-500 Agent）: 考虑增加节点数量
  • 大规模部署（>500 Agent）:
    • 使用 3+ 个 Server 节点
    • 监控缓存命中率和节点锁争用
    • 适当调整 balance_threshold（建议 1.5-2.0）
    • 确保 Redis 性能充足（低延迟、高可用）
  • 缓存优化:
    • 负载信息缓存 TTL: 5秒（代码内置）
    • Agent 元数据缓存: 按需失效（增删改时主动清理）
    • 高并发场景建议使用 Redis Cluster 提升吞吐
7. 缓存策略详解 🚀
Agent 元数据缓存

缓存目标: DescribeAgent() 方法（注册时高频调用）

缓存Key规则:

  • 按ID查询: agent:id:{agent_id}
  • 按Name查询: agent:name:{agent_name}

缓存失效策略（Write-Through + 智能过滤）:

  • ✅ CreateAgent: 新建后清理同名缓存
  • ✅ UpdateAgent: 更新后清理 ID + Name 缓存（含旧名称）
  • ✅ RegisterAgent: 注册信息更新后清理 ID + Name 缓存
  • ✅ CloseConnection: 状态变更后清理缓存（非重连场景）
  • ⚡ HeartbeatReport: 不失效缓存（性能优化）

HeartbeatReport 不失效缓存的原因:

  • 📊 心跳时间仅用于统计展示，非业务关键字段
  • ⏰ 更新频率极高（15秒/次），失效缓存会严重降低命中率
  • ✅ 最终一致性可接受（延迟几十秒不影响业务）
  • 🚀 性能收益: 缓存命中率从 <50% → >85%

优势:

  • 减少数据库查询压力（注册高峰期尤其明显）
  • 查询延迟降低至 <5ms（缓存命中时）
  • 自动失效保证关键数据一致性
  • 智能过滤非关键字段更新，避免过度失效

监控指标:

  • 缓存命中率: 建议 >85%（优化后可达 >90%）
  • 数据库查询延迟: <20ms（缓存降低影响）

数据一致性保障:

  • ✅ 关键状态（ONLINE/OFFLINE/ERROR）变更立即失效缓存
  • ✅ 注册信息（节点名、版本等）变更立即失效缓存
  • ⚠️ 心跳时间可能有缓存延迟（最大延迟 = 上次缓存建立到现在的时间）
  • 💡 如需实时心跳时间，可直接查询 HeartbeatReport API 返回值
8. 故障恢复
  • Server 节点崩溃: 其他节点自动清理过期数据，Agent 重连到可用节点
  • Redis 故障: 降级允许注册，恢复后自愈计数
  • 计数漂移: 自动检测并修复，无需人工干预
  • 注册失败: 自动回滚所有状态（计数、连接、DB）
  • 缓存穿透: 数据库查询失败不缓存，避免缓存空值
  • 心跳队列堆积: 检查数据库性能或调整批量参数
9. 生产环境部署检查清单

✅ 配置检查：

  • balance_threshold 设置合理（1.0-2.0）
  • node_timeout 不小于 60 秒
  • heartbeat_batch_interval 根据Agent规模设置（默认1s）
  • heartbeat_batch_size 根据Agent规模设置（默认100）
  • Redis 高可用配置（主从/集群）
  • 数据库连接池配置充足（建议 >20）
  • 缓存后端（Redis）性能充足

✅ 监控配置：

  • 配置负载缓存命中率监控（>90%）
  • 配置 Agent 查询缓存命中率监控（>90%）
  • 配置心跳队列大小监控（告警>500）
  • 配置心跳批量写延迟监控（告警>5s）
  • 配置节点锁争用监控
  • 配置计数漂移告警
  • 配置注册成功率监控
  • 配置数据库查询延迟监控

✅ 压力测试：

  • 模拟 100+ Agent 并发注册
  • 模拟 1000+ Agent 持续心跳（观察队列大小和DB延迟）
  • 监控内存占用（心跳队列通常 <10MB）
  • 监控数据库连接使用率
  • 验证心跳队列定期刷新成功

✅ 灰度部署建议：

  • 先小规模测试（<100 Agent）
  • 逐步扩大规模，观察性能指标
  • 根据实际负载调整 heartbeat_batch_interval 和 heartbeat_batch_size
  • 验证负载均衡效果
  • 测试节点故障恢复
  • 验证 Redis 故障降级

相关模块

  • task: 任务模块，定义任务数据结构和执行逻辑
  • agent_metric: Agent 指标模块，存储和查询监控数据
  • agent_scheduler: Agent 调度器，实现智能任务分配
  • task_log: 任务日志模块，管理日志存储和查询

Documentation

Index

Constants

View Source 
const (
	HEADER_AGENT_ID       = "x-agent-id"
	HEADER_AGENT_KEY      = "x-agent-key"
	HEADER_AGENT_HOSTNAME = "x-agent-hostname"
	HEADER_AGENT_ADDRESS  = "x-agent-address"

	HEADER_AGENT_GIT_TAG    = "x-agent-git-tag"
	HEADER_AGENT_GIT_COMMIT = "x-agent-git-commit"
	HEADER_AGENT_GIT_BRANCH = "x-agent-git-branch"
	HEADER_AGENT_BUILD_TIME = "x-agent-build-time"
)
View Source 
const (
	APP_NAME = "agent"
)

Variables

View Source 
var (
	StringToStatus = map[string]STATUS{
		"UNKNOWN": STAUTS_UNKNOWN,
		"ONLINE":  STATUS_ONLINE,
		"ERROR":   STATUS_ERROR,
		"OFFLINE": STATUS_OFFLINE,
	}
	StatusToString = map[STATUS]string{
		STAUTS_UNKNOWN: "UNKNOWN",
		STATUS_ONLINE:  "ONLINE",
		STATUS_ERROR:   "ERROR",
		STATUS_OFFLINE: "OFFLINE",
	}
)

Functions

func ComparedEncryptKey 

func ComparedEncryptKey(cipheredSrc, cipheredTarget string) (bool, error)

func DecryptAgentKey 

func DecryptAgentKey(cipheredKey string) (string, error)

func EncodeMessage 

func EncodeMessage(v any) (json.RawMessage, error)

EncodeMessage 编码消息为 JSON

func EncryptAgentKey 

func EncryptAgentKey(text string) (string, error)

Types

type Action 

type Action string
const (
	ACTION_RUN_TASK    Action = "run_task"
	ACTION_CANCEL_TASK Action = "cancel_task"
)

type Agent 

type Agent struct {
	Id         string    `json:"id" gorm:"column:id;" optional:"true" description:"Agent Id"`
	CreateTime time.Time `json:"create_time" gorm:"column:create_time;type:datetime" optional:"true" description:"创建时间"`
	UpdateTime time.Time `json:"update_time" gorm:"column:update_time;type:datetime" optional:"true" description:"更新时间"`
	CreateAgentRequest
	AgentRegistryInfo
	HeartbeatConfig
	AgentStatus
	AgentCrendential
}

func NewAgent 

func NewAgent(req CreateAgentRequest) *Agent

func (*Agent) DecryptedAgentKey 

func (r *Agent) DecryptedAgentKey() error

func (*Agent) EncryptAgentKey 

func (a *Agent) EncryptAgentKey() error

func (*Agent) LoadFromEvent 

func (e *Agent) LoadFromEvent(event *bus.Event) error

func (*Agent) RefreshCrendential 

func (r *Agent) RefreshCrendential()

func (*Agent) String 

func (a *Agent) String() string

func (*Agent) TableName 

func (a *Agent) TableName() string

func (*Agent) ToBusEvent 

func (e *Agent) ToBusEvent(topic string) *bus.Event

func (*Agent) UpdateHeartbeatAt 

func (a *Agent) UpdateHeartbeatAt(t time.Time)

func (*Agent) ValidateKey 

func (a *Agent) ValidateKey(id, key string) error

type AgentCrendential 

type AgentCrendential struct {
	// Agent Key
	Key string `json:"key" gorm:"column:key;type:varchar(200)" mask:",3,4" optional:"true" description:"Agent Key"`
	// keys会否加密
	IsEncrypted bool `json:"is_encrypted" gorm:"column:is_encrypted;type:bool" optional:"true" description:"是否加密"`

	// 凭证刷新时间
	RefreshAt time.Time `json:"refresh_at" gorm:"column:refresh_at;type:datetime" optional:"true" description:"刷新时间"`
	// 旧key
	OldKey string `json:"old_key" gorm:"column:old_key;type:varchar(200)" mask:",3,4" optional:"true" description:"旧key"`
}

func (AgentCrendential) TableName 

func (c AgentCrendential) TableName() string

type AgentMessage 

type AgentMessage struct {
	Type      MessageType     `json:"type"`
	RequestId string          `json:"request_id"`
	Data      json.RawMessage `json:"data"`
}

通用响应消息

type AgentMetricMessage 

type AgentMetricMessage struct {
	AgentId    string    `json:"agent_id"`
	ReportTime time.Time `json:"report_time"`

	// CPU 指标
	CPUUsagePercent float64 `json:"cpu_usage_percent"`
	CPUCores        int     `json:"cpu_cores"`

	// 内存指标
	MemoryUsedMB       int64   `json:"memory_used_mb"`
	MemoryTotalMB      int64   `json:"memory_total_mb"`
	MemoryUsagePercent float64 `json:"memory_usage_percent"`

	// 磁盘指标
	DiskUsedGB       int64   `json:"disk_used_gb"`
	DiskTotalGB      int64   `json:"disk_total_gb"`
	DiskUsagePercent float64 `json:"disk_usage_percent"`

	// 负载指标
	LoadAverage1  float64 `json:"load_average_1"`
	LoadAverage5  float64 `json:"load_average_5"`
	LoadAverage15 float64 `json:"load_average_15"`

	// 关键资源指标
	ProcessCount           int     `json:"process_count"`             // 系统进程总数
	InodeUsagePercent      float64 `json:"inode_usage_percent"`       // Inode 使用率 (%)
	FileHandleUsagePercent float64 `json:"file_handle_usage_percent"` // 文件句柄使用率 (%)

	// 任务执行指标
	RunningTasks int `json:"running_tasks"`

	// Runtime 指标
	GoroutineCount int `json:"goroutine_count"`
}

Agent 指标消息

type AgentRegistryInfo 

type AgentRegistryInfo struct {
	// 注册到的节点名称
	NodeName string `json:"node_name" gorm:"column:node_name;type:varchar(100)" optional:"true" description:"节点名称"`
	// Agent 运行的主机名称
	HostName string `json:"host_name" gorm:"column:host_name;type:varchar(100)" optional:"true" description:"主机名称"`
	// Address of the agent
	Address string `json:"address" validate:"required" gorm:"column:address;type:varchar(100)" description:"地址"`
	// 注册时间
	RegistryAt *time.Time `json:"registry_at" gorm:"column:registry_at;type:datetime" optional:"true" description:"注册时间"`
	// Agent 版本信息
	AgentVersion
}

func (*AgentRegistryInfo) SetNodeName 

func (r *AgentRegistryInfo) SetNodeName(name string)

func (*AgentRegistryInfo) SetRegistryAt 

func (r *AgentRegistryInfo) SetRegistryAt(t time.Time)

func (*AgentRegistryInfo) String 

func (r *AgentRegistryInfo) String() string

func (*AgentRegistryInfo) TableName 

func (r *AgentRegistryInfo) TableName() string

type AgentRegistryInfoRequest 

type AgentRegistryInfoRequest struct {
	AgentRegistryInfo
	AgentStatus
}

func (*AgentRegistryInfoRequest) TableName 

func (r *AgentRegistryInfoRequest) TableName() string

type AgentRegistryRequest 

type AgentRegistryRequest struct {
	// Agent Id
	AgentId string `json:"agent_id" description:"Agent Id"`
	// Agent Key
	AgentKey string `json:"agent_key" description:"Agent Key"`
	// 注册
	AgentRegistryInfo
	// contains filtered or unexported fields
}

func NewAgentRegistryRequest 

func NewAgentRegistryRequest() *AgentRegistryRequest

func (*AgentRegistryRequest) GetWebSocketConn 

func (a *AgentRegistryRequest) GetWebSocketConn() *websocket.Conn

func (*AgentRegistryRequest) SetWebSocketConn 

func (a *AgentRegistryRequest) SetWebSocketConn(conn *websocket.Conn)

type AgentStatus 

type AgentStatus struct {
	// Status of the agent
	Status STATUS `` /* 142-byte string literal not displayed */
	// Message of the agent
	Message string `json:"message" gorm:"column:message;type:text" optional:"true" description:"状态描述"`
	// 最近一次上报心态报的时间
	LatestHeartbeatAt *time.Time `` /* 141-byte string literal not displayed */
	// 离线时间
	OfflineAt *time.Time `json:"offline_at" gorm:"column:offline_at;type:datetime" optional:"true" description:"离线时间"`
}

func NewAgentOnlineStatus 

func NewAgentOnlineStatus() *AgentStatus

func (*AgentStatus) Error 

func (r *AgentStatus) Error(err error)

func (*AgentStatus) IsOnline 

func (r *AgentStatus) IsOnline() bool

func (*AgentStatus) Offline 

func (r *AgentStatus) Offline(t time.Time)

func (*AgentStatus) Online 

func (r *AgentStatus) Online(t time.Time)

func (*AgentStatus) SetLatestHeartbeatAt 

func (r *AgentStatus) SetLatestHeartbeatAt(t time.Time)

func (*AgentStatus) SetOfflineAt 

func (r *AgentStatus) SetOfflineAt(t time.Time)

func (*AgentStatus) SetStatus 

func (r *AgentStatus) SetStatus(status STATUS)

func (*AgentStatus) String 

func (r *AgentStatus) String() string

func (*AgentStatus) TableName 

func (r *AgentStatus) TableName() string

func (*AgentStatus) Unknown 

func (r *AgentStatus) Unknown(msg string)

type AgentVersion 

type AgentVersion struct {
	// Git Tag
	GitTag string `json:"git_tag" gorm:"column:git_tag;type:varchar(100)" optional:"true" description:"Git Tag"`
	// Build Time
	BuildTime string `json:"build_time" gorm:"column:build_time;type:varchar(100)" optional:"true" description:"Build Time"`
	// Git Branch
	GitBranch string `json:"git_branch" gorm:"column:git_branch;type:varchar(100)" optional:"true" description:"Git Branch"`
	// Git Commit
	GitCommit string `json:"git_commit" gorm:"column:git_commit;type:varchar(100)" optional:"true" description:"Git Commit"`
}

type CloseConnectionRequest 

type CloseConnectionRequest struct {
	GetConnectionRequest
	// 是否跳过计数递减（用于重连场景）
	SkipDecrement bool `json:"skip_decrement"`
	// 是否跳过设置 OFFLINE 状态（用于重连场景，避免状态污染）
	SkipOffline bool `json:"skip_offline"`
}

func NewCloseConnectionRequest 

func NewCloseConnectionRequest(agentId string) *CloseConnectionRequest

func (*CloseConnectionRequest) SetSkipDecrement 

func (r *CloseConnectionRequest) SetSkipDecrement(skip bool) *CloseConnectionRequest

func (*CloseConnectionRequest) SetSkipOffline 

func (r *CloseConnectionRequest) SetSkipOffline(skip bool) *CloseConnectionRequest

type Connection 

type Connection struct {
	Agent *Agent
	// contains filtered or unexported fields
}

func NewConnection 

func NewConnection(ws *websocket.Conn, agent *Agent) *Connection

func (*Connection) Close 

func (c *Connection) Close() error

func (*Connection) GetErrorChan 

func (c *Connection) GetErrorChan() <-chan error

GetErrorChan 获取错误通知channel

func (*Connection) RegisterMessageHandler 

func (c *Connection) RegisterMessageHandler(msgType MessageType, handler ResponseHandler)

RegisterMessageHandler 注册消息处理器

func (*Connection) RunTask 

func (c *Connection) RunTask(req *RunTaskRequest) error

通过Agent连接 通知Agent执行任务

func (*Connection) SetLogger 

func (c *Connection) SetLogger(log *zerolog.Logger) *Connection

SetLogger 设置日志器

func (*Connection) StartMessageLoop 

func (c *Connection) StartMessageLoop(ctx context.Context)

StartMessageLoop 启动消息循环，处理来自 Agent 的响应 返回error channel用于通知连接错误

type CreateAgentRequest 

type CreateAgentRequest struct {
	// 哪些环境下运行
	Envs []string `json:"envs" validate:"required" gorm:"column:envs;type:json;serializer:json;not null;default:'[]'" description:"环境名称"`
	// Name of the agent
	Name string `json:"name" validate:"required" gorm:"column:name;type:varchar(100)" description:"名称"`
	// Description of the agent
	Description string `json:"description" validate:"required" gorm:"column:description;type:text" description:"描述"`
	// Enabled status of the agent
	Enabled *bool `json:"enabled" gorm:"column:enabled;type:bool" description:"是否启用"`
	// 允许运行中的最大任务数
	MaxRunningTasks int `json:"max_running_tasks" gorm:"column:max_running_tasks;type:int" description:"允许运行中的最大任务数"`
	// Metadata of the agent
	Metadata map[string]string `` /* 126-byte string literal not displayed */
	// Tags of the agent
	Label map[string]string `json:"label" gorm:"column:label;type:json;serializer:json;not null;default:'{}'" optional:"true" description:"标签"`
	// Features of the agent, 比如是否支持 镜像扫描, 镜像上传
	Features []string `` /* 196-byte string literal not displayed */
}

func NewCreateAgentRequest 

func NewCreateAgentRequest() *CreateAgentRequest

func (*CreateAgentRequest) AddEnv 

func (r *CreateAgentRequest) AddEnv(envs ...string)

func (*CreateAgentRequest) AddFeature 

func (r *CreateAgentRequest) AddFeature(features ...string)

func (*CreateAgentRequest) Validate 

func (r *CreateAgentRequest) Validate() error

type DESCRIBE_BY 

type DESCRIBE_BY int
const (
	DESCRIBE_BY_ID DESCRIBE_BY = iota
	DESCRIBE_BY_NAME
)

type DescribeAgentRequest 

type DescribeAgentRequest struct {
	// 方式
	DescribeBy DESCRIBE_BY `json:"describe_by"`
	// Agent ID
	Value string `json:"value"`
}

func NewDescribeAgentRequest 

func NewDescribeAgentRequest(id string) *DescribeAgentRequest

func (*DescribeAgentRequest) WithId 

func (r *DescribeAgentRequest) WithId(id string) *DescribeAgentRequest

func (*DescribeAgentRequest) WithName 

func (r *DescribeAgentRequest) WithName(name string) *DescribeAgentRequest

type GetConnectionRequest 

type GetConnectionRequest struct {
	AgentId string `json:"agent_id" validate:"required"`
}

func NewGetConnectionRequest 

func NewGetConnectionRequest(agentId string) *GetConnectionRequest

type HeartbeatConfig 

type HeartbeatConfig struct {
	// 心跳间隔时间，单位秒
	IntervalSec int `json:"interval_sec" gorm:"column:interval_sec;type:int" description:"心跳间隔时间，单位秒"`
	// 最大允许丢失心跳次数
	MaxMissed int `json:"max_missed" gorm:"column:max_missed;type:int" description:"最大允许丢失心跳次数"`
}

type HeartbeatReportRequest 

type HeartbeatReportRequest struct {
	AgentId string `json:"agent_id" validate:"required"`
}

func NewHeartbeatReportRequest 

func NewHeartbeatReportRequest(agentId string) *HeartbeatReportRequest

type HeartbeatReportResponse 

type HeartbeatReportResponse struct {
	Agent *Agent `json:"agent"`
}

type MessageType 

type MessageType string

消息类型 

const (
	MESSAGE_TYPE_TASK_RESULT  MessageType = "task_result"  // 任务结果
	MESSAGE_TYPE_TASK_LOG     MessageType = "task_log"     // 任务日志
	MESSAGE_TYPE_TASK_CONFIRM MessageType = "task_confirm" // 任务调度确认
	MESSAGE_TYPE_AGENT_METRIC MessageType = "agent_metric" // Agent 指标上报
)

type QueryAgentRequest 

type QueryAgentRequest struct {
	request.PageRequest
	// 环境名称
	EnvName *string `json:"env_name" form:"env_name"`
	// Agent状态
	Enabled *bool `json:"enabled" form:"enabled"`
	// AgentIds
	AgentIds []string `json:"agent_ids" form:"agent_ids"`
	// 特性, 比如sam_deploy
	Feature string `json:"feature" form:"feature"`
	// 资源标签过滤
	Label map[string]string `json:"label" form:"label"`
	// 状态
	Status *STATUS `json:"status" form:"status"`
}

func NewQueryAgentRequest 

func NewQueryAgentRequest() *QueryAgentRequest

func (*QueryAgentRequest) SetEnabled 

func (r *QueryAgentRequest) SetEnabled(v bool) *QueryAgentRequest

func (*QueryAgentRequest) SetEnvName 

func (r *QueryAgentRequest) SetEnvName(v string) *QueryAgentRequest

func (*QueryAgentRequest) SetFeature 

func (r *QueryAgentRequest) SetFeature(v string) *QueryAgentRequest

func (*QueryAgentRequest) SetStatus 

func (r *QueryAgentRequest) SetStatus(v STATUS) *QueryAgentRequest

func (*QueryAgentRequest) String 

func (r *QueryAgentRequest) String() string

type Register 

type Register interface {
	// 注册Agent
	RegisterAgent(context.Context, *AgentRegistryRequest) (*Connection, error)
	// 获取连接
	GetConnection(context.Context, *GetConnectionRequest) (*Connection, error)
	// 关闭连接
	CloseConnection(context.Context, *CloseConnectionRequest) error
	// 心跳上报
	HeartbeatReport(context.Context, *HeartbeatReportRequest) (*HeartbeatReportResponse, error)
}

func GetRegister 

func GetRegister() Register

type ResponseHandler 

type ResponseHandler interface {
	HandleResponse(ctx context.Context, msg *AgentMessage) error
}

响应处理器接口

type RunTaskRequest 

type RunTaskRequest struct {
	RequestId string     `json:"request_id"`
	Action    Action     `json:"action"`
	Task      *task.Task `json:"task"`
	// contains filtered or unexported fields
}

func NewRunTaskRequest 

func NewRunTaskRequest(action Action, task *task.Task) *RunTaskRequest

func (*RunTaskRequest) LoadFromEvent 

func (e *RunTaskRequest) LoadFromEvent(event *bus.Event) error

func (*RunTaskRequest) LogCallback 

func (r *RunTaskRequest) LogCallback() func(content string)

LogCallback 获取日志回调函数

func (*RunTaskRequest) LogDebug 

func (r *RunTaskRequest) LogDebug(msg string)

LogDebug 输出 DEBUG 日志（委托给Task对象）

func (*RunTaskRequest) LogError 

func (r *RunTaskRequest) LogError(msg string)

LogError 输出 ERROR 日志（委托给Task对象）

func (*RunTaskRequest) LogInfo 

func (r *RunTaskRequest) LogInfo(msg string)

LogInfo 输出 INFO 日志（委托给Task对象）

func (*RunTaskRequest) LogSuccess 

func (r *RunTaskRequest) LogSuccess(msg string)

LogSuccess 输出 SUCCESS 日志（委托给Task对象）

func (*RunTaskRequest) LogWarn 

func (r *RunTaskRequest) LogWarn(msg string)

LogWarn 输出 WARNING 日志（委托给Task对象）

func (*RunTaskRequest) SetLogCallback 

func (r *RunTaskRequest) SetLogCallback(callback func(content string)) *RunTaskRequest

SetLogCallback 设置日志回调函数（直接设置到Task对象）

func (*RunTaskRequest) String 

func (r *RunTaskRequest) String() string

func (*RunTaskRequest) ToBusEvent 

func (e *RunTaskRequest) ToBusEvent(topic string) *bus.Event

type RunTaskResponse 

type RunTaskResponse struct {
	RunTaskRequest
	*script.ExecutionResult
}

func NewRunTaskResponse 

func NewRunTaskResponse(req *RunTaskRequest, result *script.ExecutionResult) *RunTaskResponse

func (*RunTaskResponse) UpdateTaskStatus 

func (r *RunTaskResponse) UpdateTaskStatus()

注意 Log已经通过LogCallback回调函数发送，不需要在这里携带

type STATUS 

type STATUS int
const (
	// StatusUnknown is the unknown status
	STAUTS_UNKNOWN STATUS = iota
	// StatusOnline is the online status
	STATUS_ONLINE
	// StatusError is the error status
	STATUS_ERROR
	// StatusOffline is the offline status
	STATUS_OFFLINE
)

func ParseSTATUSFromString 

func ParseSTATUSFromString(s string) STATUS

ParseSTATUSFromString 从字符串解析 STATUS

func (STATUS) MarshalJSON 

func (t STATUS) MarshalJSON() ([]byte, error)

func (*STATUS) UnmarshalJSON 

func (t *STATUS) UnmarshalJSON(data []byte) error

type Service 

type Service interface {
	// 创建Agent
	CreateAgent(context.Context, *CreateAgentRequest) (*Agent, error)
	// 更新Agent
	UpdateAgent(context.Context, *UpdateAgentRequest) (*Agent, error)
	// 查询列表
	QueryAgent(context.Context, *QueryAgentRequest) (*types.Set[*Agent], error)
	// 查询详情
	DescribeAgent(context.Context, *DescribeAgentRequest) (*Agent, error)

	// 运行任务
	RunTask(context.Context, *task.Task) error
}

func GetService 

func GetService() Service

type TaskConfirmMessage 

type TaskConfirmMessage struct {
	TaskId  string `json:"task_id"`
	AgentId string `json:"agent_id"`
}

调度确认消息

type TaskHandler 

type TaskHandler interface {
	// HandleTask 任务处理
	HandleTask(context.Context, *RunTaskRequest) (*RunTaskResponse, error)
}

type TaskLogMessage 

type TaskLogMessage struct {
	TaskId   string    `json:"task_id"`
	Content  string    `json:"content"`
	Time     time.Time `json:"time"`     // 精确时间（纳秒级）
	Sequence int64     `json:"sequence"` // 序列号，同一秒内的顺序
}

日志消息

type UpdateAgentRequest 

type UpdateAgentRequest struct {
	// Id
	DescribeAgentRequest
	// Agent 信息
	CreateAgentRequest
}

func NewUpdateAgentRequest 

func NewUpdateAgentRequest() *UpdateAgentRequest

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.