15.1 分布式任务调度高可用方案竟然还能这样做？

15.1 太震撼了！分布式任务调度高可用方案竟然还能这样做？

在分布式任务调度系统中，高可用性是至关重要的。一个高可用的调度系统需要确保即使在部分节点故障的情况下，任务仍然能够被正确调度和执行。今天我们就来深入探讨如何设计一个高可用的分布式任务调度系统。

高可用架构设计原则

高可用的分布式任务调度系统需要遵循以下设计原则：

1. 无单点故障：系统中任何一个组件的故障都不应该导致整个系统不可用
2. 故障自动恢复：系统应该能够自动检测故障并进行恢复
3. 数据一致性：在故障恢复后，系统状态应该保持一致
4. 优雅降级：在部分功能不可用时，系统应该能够提供核心功能

负载均衡与再均衡机制

负载均衡是高可用系统的核心组件之一。在分布式任务调度系统中，我们需要实现基于节点负载的动态调度和再均衡机制。

package loadbalancer

import (
    "sync"
    "time"
    "math/rand"
)

// NodeInfo 节点信息
type NodeInfo struct {
    ID        string
    Address   string
    Load      int64     // 负载值
    LastHeartbeat time.Time
    Status    NodeStatus
}

// NodeStatus 节点状态
type NodeStatus int

const (
    NodeStatusHealthy NodeStatus = iota
    NodeStatusUnhealthy
    NodeStatusOffline
)

// LoadBalancer 负载均衡器
type LoadBalancer struct {
    nodes map[string]*NodeInfo
    mu    sync.RWMutex
}

// NewLoadBalancer 创建负载均衡器
func NewLoadBalancer() *LoadBalancer {
    return &LoadBalancer{
        nodes: make(map[string]*NodeInfo),
    }
}

// AddNode 添加节点
func (lb *LoadBalancer) AddNode(id, address string) {
    lb.mu.Lock()
    defer lb.mu.Unlock()
    
    lb.nodes[id] = &NodeInfo{
        ID:            id,
        Address:       address,
        Load:          0,
        LastHeartbeat: time.Now(),
        Status:        NodeStatusHealthy,
    }
}

// RemoveNode 移除节点
func (lb *LoadBalancer) RemoveNode(id string) {
    lb.mu.Lock()
    defer lb.mu.Unlock()
    
    delete(lb.nodes, id)
}

// UpdateNodeLoad 更新节点负载
func (lb *LoadBalancer) UpdateNodeLoad(id string, load int64) error {
    lb.mu.Lock()
    defer lb.mu.Unlock()
    
    node, exists := lb.nodes[id]
    if !exists {
        return ErrNodeNotFound
    }
    
    node.Load = load
    node.LastHeartbeat = time.Now()
    return nil
}

// SelectNode 选择节点（基于负载的策略）
func (lb *LoadBalancer) SelectNode() (*NodeInfo, error) {
    lb.mu.RLock()
    defer lb.mu.RUnlock()
    
    if len(lb.nodes) == 0 {
        return nil, ErrNoAvailableNodes
    }
    
    // 过滤出健康的节点
    var healthyNodes []*NodeInfo
    now := time.Now()
    for _, node := range lb.nodes {
        // 检查节点是否在最近时间内有心跳
        if now.Sub(node.LastHeartbeat) < 30*time.Second && node.Status == NodeStatusHealthy {
            healthyNodes = append(healthyNodes, node)
        }
    }
    
    if len(healthyNodes) == 0 {
        return nil, ErrNoHealthyNodes
    }
    
    // 选择负载最低的节点
    selectedNode := healthyNodes[0]
    for _, node := range healthyNodes {
        if node.Load < selectedNode.Load {
            selectedNode = node
        }
    }
    
    return selectedNode, nil
}

// Rebalance 再均衡策略
func (lb *LoadBalancer) Rebalance() ([]RebalanceAction, error) {
    lb.mu.RLock()
    defer lb.mu.RUnlock()
    
    var actions []RebalanceAction
    
    // 计算平均负载
    var totalLoad int64
    var healthyNodes []*NodeInfo
    
    now := time.Now()
    for _, node := range lb.nodes {
        if now.Sub(node.LastHeartbeat) < 30*time.Second && node.Status == NodeStatusHealthy {
            totalLoad += node.Load
            healthyNodes = append(healthyNodes, node)
        }
    }
    
    if len(healthyNodes) == 0 {
        return actions, nil
    }
    
    avgLoad := totalLoad / int64(len(healthyNodes))
    
    // 识别需要迁移任务的节点
    for _, node := range healthyNodes {
        // 如果节点负载超过平均负载的1.5倍，考虑迁移任务
        if node.Load > avgLoad*3/2 {
            // 计算需要迁移的负载量
            excessLoad := node.Load - avgLoad
            actions = append(actions, RebalanceAction{
                FromNode:   node.ID,
                ExcessLoad: excessLoad,
            })
        }
    }
    
    return actions, nil
}

// RebalanceAction 再均衡操作
type RebalanceAction struct {
    FromNode   string
    ExcessLoad int64
}

// 错误定义
var (
    ErrNodeNotFound    = &LoadBalancerError{"node not found"}
    ErrNoAvailableNodes = &LoadBalancerError{"no available nodes"}
    ErrNoHealthyNodes   = &LoadBalancerError{"no healthy nodes"}
)

// LoadBalancerError 负载均衡器错误
type LoadBalancerError struct {
    message string
}

func (e *LoadBalancerError) Error() string {
    return e.message
}

// 使用示例
func ExampleLoadBalancer() {
    lb := NewLoadBalancer()
    
    // 添加节点
    lb.AddNode("node1", "192.168.1.10:8080")
    lb.AddNode("node2", "192.168.1.11:8080")
    lb.AddNode("node3", "192.168.1.12:8080")
    
    // 模拟更新节点负载
    lb.UpdateNodeLoad("node1", 10)
    lb.UpdateNodeLoad("node2", 25)
    lb.UpdateNodeLoad("node3", 5)
    
    // 选择节点
    node, err := lb.SelectNode()
    if err != nil {
        panic(err)
    }
    
    // 输出选择的节点
    println("Selected node:", node.ID, "with load:", node.Load)
    
    // 执行再均衡
    actions, err := lb.Rebalance()
    if err != nil {
        panic(err)
    }
    
    for _, action := range actions {
        println("Need to rebalance from node:", action.FromNode, "excess load:", action.ExcessLoad)
    }
}

任务中断与重调度机制

在分布式环境中，任务执行可能会因为节点故障而中断。我们需要实现任务中断检测和重调度机制，确保任务能够继续执行。

package rescheduler

import (
    "context"
    "fmt"
    "sync"
    "time"
)

// TaskState 任务状态
type TaskState int

const (
    TaskStatePending TaskState = iota
    TaskStateRunning
    TaskStateCompleted
    TaskStateFailed
    TaskStateInterrupted
)

// Task 任务信息
type Task struct {
    ID          string
    State       TaskState
    AssignedNode string
    Payload     map[string]interface{}
    Result      interface{}
    Error       string
    StartTime   time.Time
    EndTime     time.Time
    RetryCount  int
    MaxRetries  int
    Checkpoint  interface{} // 任务检查点，用于恢复
}

// TaskManager 任务管理器
type TaskManager struct {
    tasks map[string]*Task
    mu    sync.RWMutex
}

// NewTaskManager 创建任务管理器
func NewTaskManager() *TaskManager {
    return &TaskManager{
        tasks: make(map[string]*Task),
    }
}

// AddTask 添加任务
func (tm *TaskManager) AddTask(task *Task) {
    tm.mu.Lock()
    defer tm.mu.Unlock()
    
    tm.tasks[task.ID] = task
}

// GetTask 获取任务
func (tm *TaskManager) GetTask(id string) (*Task, bool) {
    tm.mu.RLock()
    defer tm.mu.RUnlock()
    
    task, exists := tm.tasks[id]
    return task, exists
}

// UpdateTaskState 更新任务状态
func (tm *TaskManager) UpdateTaskState(id string, state TaskState, result interface{}, err string) error {
    tm.mu.Lock()
    defer tm.mu.Unlock()
    
    task, exists := tm.tasks[id]
    if !exists {
        return fmt.Errorf("task %s not found", id)
    }
    
    task.State = state
    task.Result = result
    task.Error = err
    
    if state == TaskStateCompleted || state == TaskStateFailed {
        task.EndTime = time.Now()
    }
    
    return nil
}

// InterruptTask 中断任务
func (tm *TaskManager) InterruptTask(id string) error {
    tm.mu.Lock()
    defer tm.mu.Unlock()
    
    task, exists := tm.tasks[id]
    if !exists {
        return fmt.Errorf("task %s not found", id)
    }
    
    task.State = TaskStateInterrupted
    task.EndTime = time.Now()
    
    return nil
}

// RescheduleTask 重调度任务
func (tm *TaskManager) RescheduleTask(ctx context.Context, id string, newNode string) error {
    tm.mu.Lock()
    defer tm.mu.Unlock()
    
    task, exists := tm.tasks[id]
    if !exists {
        return fmt.Errorf("task %s not found", id)
    }
    
    // 检查重试次数
    if task.RetryCount >= task.MaxRetries {
        task.State = TaskStateFailed
        task.Error = "max retries exceeded"
        return fmt.Errorf("task %s exceeded max retries", id)
    }
    
    // 更新任务信息
    task.RetryCount++
    task.AssignedNode = newNode
    task.State = TaskStatePending
    task.StartTime = time.Time{} // 重置开始时间
    task.EndTime = time.Time{}   // 重置结束时间
    
    // 如果有检查点，可以从检查点恢复
    // 这里简化处理，实际应用中需要根据具体业务逻辑实现
    
    return nil
}

// DetectInterruptedTasks 检测中断的任务
func (tm *TaskManager) DetectInterruptedTasks() ([]string, error) {
    tm.mu.RLock()
    defer tm.mu.RUnlock()
    
    var interruptedTasks []string
    
    for _, task := range tm.tasks {
        // 检查长时间运行但没有更新状态的任务
        if task.State == TaskStateRunning {
            // 如果任务运行时间超过预期时间的3倍，认为可能中断了
            // 这里简化处理，实际应用中需要更复杂的检测机制
            if !task.StartTime.IsZero() && time.Since(task.StartTime) > 10*time.Minute {
                interruptedTasks = append(interruptedTasks, task.ID)
            }
        }
    }
    
    return interruptedTasks, nil
}

// 使用示例
func ExampleTaskManager() {
    tm := NewTaskManager()
    
    // 添加任务
    task := &Task{
        ID:         "task_001",
        State:      TaskStatePending,
        Payload:    map[string]interface{}{"data": "sample data"},
        MaxRetries: 3,
    }
    
    tm.AddTask(task)
    
    // 模拟任务开始执行
    task.State = TaskStateRunning
    task.StartTime = time.Now()
    task.AssignedNode = "node1"
    
    // 模拟任务中断
    tm.InterruptTask("task_001")
    
    // 检测中断的任务
    interruptedTasks, err := tm.DetectInterruptedTasks()
    if err != nil {
        panic(err)
    }
    
    for _, taskID := range interruptedTasks {
        println("Detected interrupted task:", taskID)
        // 重调度到新节点
        tm.RescheduleTask(context.Background(), taskID, "node2")
    }
}

容错机制实现

容错机制是高可用系统的重要组成部分。我们需要实现调度节点和执行节点的容错机制，确保在节点故障时系统能够继续运行。

package faulttolerance

import (
    "context"
    "fmt"
    "sync"
    "time"
)

// NodeManager 节点管理器
type NodeManager struct {
    nodes map[string]*NodeInfo
    mu    sync.RWMutex
}

// NodeInfo 节点信息
type NodeInfo struct {
    ID          string
    Address     string
    NodeType    NodeType
    Status      NodeStatus
    LastCheck   time.Time
    Failures    int
    MaxFailures int
}

// NodeType 节点类型
type NodeType int

const (
    NodeTypeScheduler NodeType = iota
    NodeTypeExecutor
)

// NodeStatus 节点状态
type NodeStatus int

const (
    NodeStatusActive NodeStatus = iota
    NodeStatusInactive
    NodeStatusFailed
)

// NewNodeManager 创建节点管理器
func NewNodeManager() *NodeManager {
    return &NodeManager{
        nodes: make(map[string]*NodeInfo),
    }
}

// AddNode 添加节点
func (nm *NodeManager) AddNode(node *NodeInfo) {
    nm.mu.Lock()
    defer nm.mu.Unlock()
    
    nm.nodes[node.ID] = node
}

// RemoveNode 移除节点
func (nm *NodeManager) RemoveNode(id string) {
    nm.mu.Lock()
    defer nm.mu.Unlock()
    
    delete(nm.nodes, id)
}

// ReportNodeFailure 报告节点故障
func (nm *NodeManager) ReportNodeFailure(id string) error {
    nm.mu.Lock()
    defer nm.mu.Unlock()
    
    node, exists := nm.nodes[id]
    if !exists {
        return fmt.Errorf("node %s not found", id)
    }
    
    node.Failures++
    node.LastCheck = time.Now()
    
    // 如果故障次数超过阈值，标记为失败
    if node.Failures >= node.MaxFailures {
        node.Status = NodeStatusFailed
    }
    
    return nil
}

// GetHealthyNodes 获取健康节点
func (nm *NodeManager) GetHealthyNodes(nodeType NodeType) []*NodeInfo {
    nm.mu.RLock()
    defer nm.mu.RUnlock()
    
    var healthyNodes []*NodeInfo
    now := time.Now()
    
    for _, node := range nm.nodes {
        // 检查节点类型和状态
        if node.NodeType == nodeType && node.Status == NodeStatusActive {
            // 检查最近是否有心跳
            if now.Sub(node.LastCheck) < 30*time.Second {
                healthyNodes = append(healthyNodes, node)
            }
        }
    }
    
    return healthyNodes
}

// Failover 节点故障转移
func (nm *NodeManager) Failover(ctx context.Context, failedNodeID string) error {
    nm.mu.Lock()
    defer nm.mu.Unlock()
    
    failedNode, exists := nm.nodes[failedNodeID]
    if !exists {
        return fmt.Errorf("failed node %s not found", failedNodeID)
    }
    
    // 标记节点为失败状态
    failedNode.Status = NodeStatusFailed
    failedNode.LastCheck = time.Now()
    
    // 根据节点类型执行不同的故障转移策略
    switch failedNode.NodeType {
    case NodeTypeScheduler:
        return nm.failoverScheduler(ctx, failedNode)
    case NodeTypeExecutor:
        return nm.failoverExecutor(ctx, failedNode)
    default:
        return fmt.Errorf("unknown node type: %v", failedNode.NodeType)
    }
}

// failoverScheduler 调度节点故障转移
func (nm *NodeManager) failoverScheduler(ctx context.Context, failedNode *NodeInfo) error {
    // 查找备用调度节点
    var backupNodes []*NodeInfo
    for _, node := range nm.nodes {
        if node.NodeType == NodeTypeScheduler && 
           node.Status == NodeStatusActive && 
           node.ID != failedNode.ID {
            backupNodes = append(backupNodes, node)
        }
    }
    
    if len(backupNodes) == 0 {
        return fmt.Errorf("no backup scheduler nodes available")
    }
    
    // 选择一个备用节点进行故障转移
    // 这里简化处理，实际应用中可能需要更复杂的选举算法
    backupNode := backupNodes[0]
    
    // 执行故障转移操作
    // 1. 将失败节点的任务重新分配
    // 2. 通知其他组件使用新的调度节点
    // 3. 同步状态信息
    
    fmt.Printf("Failover scheduler from %s to %s\n", failedNode.ID, backupNode.ID)
    
    return nil
}

// failoverExecutor 执行节点故障转移
func (nm *NodeManager) failoverExecutor(ctx context.Context, failedNode *NodeInfo) error {
    // 查找备用执行节点
    var backupNodes []*NodeInfo
    for _, node := range nm.nodes {
        if node.NodeType == NodeTypeExecutor && 
           node.Status == NodeStatusActive && 
           node.ID != failedNode.ID {
            backupNodes = append(backupNodes, node)
        }
    }
    
    if len(backupNodes) == 0 {
        return fmt.Errorf("no backup executor nodes available")
    }
    
    // 执行故障转移操作
    // 1. 将失败节点上正在执行的任务重新调度到其他节点
    // 2. 通知调度器更新任务状态
    
    fmt.Printf("Failover executor from %s to one of %d backup nodes\n", failedNode.ID, len(backupNodes))
    
    return nil
}

// HealthCheck 健康检查
func (nm *NodeManager) HealthCheck(ctx context.Context) {
    nm.mu.RLock()
    nodes := make([]*NodeInfo, 0, len(nm.nodes))
    for _, node := range nm.nodes {
        nodes = append(nodes, node)
    }
    nm.mu.RUnlock()
    
    for _, node := range nodes {
        // 执行健康检查
        // 这里简化处理，实际应用中需要发送心跳请求或执行健康检查任务
        healthy := nm.checkNodeHealth(ctx, node)
        
        nm.mu.Lock()
        if healthy {
            node.Status = NodeStatusActive
            node.Failures = 0 // 重置故障计数
        } else {
            node.Failures++
            if node.Failures >= node.MaxFailures {
                node.Status = NodeStatusFailed
                // 触发故障转移
                go nm.Failover(ctx, node.ID)
            }
        }
        node.LastCheck = time.Now()
        nm.mu.Unlock()
    }
}

// checkNodeHealth 检查节点健康状态
func (nm *NodeManager) checkNodeHealth(ctx context.Context, node *NodeInfo) bool {
    // 这里简化处理，实际应用中需要发送网络请求检查节点状态
    // 例如发送ping请求或执行健康检查接口调用
    
    // 模拟健康检查结果
    return true
}

// 使用示例
func ExampleNodeManager() {
    nm := NewNodeManager()
    
    // 添加调度节点
    schedulerNode := &NodeInfo{
        ID:          "scheduler_1",
        Address:     "192.168.1.10:8080",
        NodeType:    NodeTypeScheduler,
        Status:      NodeStatusActive,
        MaxFailures: 3,
    }
    
    nm.AddNode(schedulerNode)
    
    // 添加执行节点
    executorNode := &NodeInfo{
        ID:          "executor_1",
        Address:     "192.168.1.11:8080",
        NodeType:    NodeTypeExecutor,
        Status:      NodeStatusActive,
        MaxFailures: 3,
    }
    
    nm.AddNode(executorNode)
    
    // 模拟节点故障
    nm.ReportNodeFailure("executor_1")
    nm.ReportNodeFailure("executor_1")
    nm.ReportNodeFailure("executor_1") // 达到最大故障次数
    
    // 执行故障转移
    ctx := context.Background()
    nm.Failover(ctx, "executor_1")
    
    // 获取健康节点
    healthySchedulers := nm.GetHealthyNodes(NodeTypeScheduler)
    healthyExecutors := nm.GetHealthyNodes(NodeTypeExecutor)
    
    fmt.Printf("Healthy schedulers: %d\n", len(healthySchedulers))
    fmt.Printf("Healthy executors: %d\n", len(healthyExecutors))
}

总结

今天我们深入探讨了分布式任务调度系统的高可用设计，包括：

1. 负载均衡与再均衡机制：实现了基于节点负载的动态调度和再均衡策略，确保任务在各节点间均匀分布。

2. 任务中断与重调度机制：设计了任务中断检测和重调度机制，确保在节点故障时任务能够继续执行。

3. 容错机制：实现了节点管理、故障检测和故障转移机制，确保系统在部分节点故障时仍能正常运行。

通过这些机制的组合，我们可以构建一个高可用的分布式任务调度系统，即使在部分组件故障的情况下也能保证任务的正常调度和执行。在下一节中，我们将继续探讨任务执行的超时控制、优雅启停以及重试策略等高级特性。