多Jenkins实例共享同一节点的互斥使用实现方法问询

这个需求完全可以实现，我之前帮团队处理过类似的跨Jenkins实例节点互斥使用场景，下面给你几个可行的方案，从简单到复杂都有：

方案一：基于REST API的节点状态互控 #

这是最直接的实现方式，利用Jenkins自带的REST API来控制对方实例的节点状态，核心思路是：

• 当Jenkins A要在Node A上执行任务前，先调用Jenkins B的API将Node A标记为离线（附带“被Jenkins A占用”的说明）
• Jenkins A任务执行完成后，再调用Jenkins B的API将Node A恢复在线
• Jenkins B执行任务时做完全相同的反向操作

具体实现步骤： #

1. 分别在两个Jenkins实例中创建具有节点管理权限的服务账号，并生成API Token（在用户配置页面的「API Token」部分生成）
2. 在Jenkins的Pipeline中添加前置/后置步骤，示例代码如下：

pipeline {
    agent { label 'NodeA' }
    stages {
        stage('Prep') {
            steps {
                // 调用Jenkins B的API将NodeA设为离线
                sh '''
                    curl -X POST -u "jenkins-service-account:your-api-token" \
                    "http://jenkins-b.example.com/computer/NodeA/toggleOffline?offlineMessage=Used+by+Jenkins+A"
                '''
            }
        }
        // 你的业务任务阶段
        stage('Build') {
            steps {
                echo 'Running build on NodeA...'
            }
        }
    }
    post {
        always {
            // 无论任务成功失败，都恢复Jenkins B的NodeA在线状态
            sh '''
                curl -X POST -u "jenkins-service-account:your-api-token" \
                "http://jenkins-b.example.com/computer/NodeA/toggleOffline?offlineMessage="
            '''
        }
    }
}

3. 注意事项：
   • 要处理API调用失败的情况（比如对方Jenkins实例宕机），可以添加重试逻辑
   • 建议给离线消息加上时间戳，方便排查问题

方案二：基于分布式锁的协调机制 #

如果担心API互控的耦合性太高，可以引入一个外部分布式锁服务（比如Redis、ZooKeeper），让两个Jenkins实例通过抢锁来决定谁能使用Node A，核心逻辑：

• 两个Jenkins实例在使用Node A前，先尝试获取分布式锁
• 抢到锁的实例正常执行任务，同时可以选择调用对方API将Node A设为离线（也可以不操作，因为没抢到锁的实例会看到节点被占用）
• 任务完成后释放锁，没抢到锁的实例会在锁释放后重试

具体实现： #

• 可以使用Jenkins的Redis Lock插件或者在Pipeline中直接调用Redis命令来实现锁逻辑
• 示例Redis锁逻辑（用Groovy脚本）：

def acquireLock() {
    def lockKey = "jenkins-nodeA-lock"
    def lockValue = UUID.randomUUID().toString()
    // 设置锁，有效期3600秒（防止实例崩溃导致锁永久持有）
    def result = sh(script: "redis-cli SET ${lockKey} ${lockValue} NX EX 3600", returnStdout: true).trim()
    return result == "OK" ? lockValue : null
}

def releaseLock(lockValue) {
    def lockKey = "jenkins-nodeA-lock"
    // 使用Lua脚本原子释放锁，避免误删其他实例的锁
    sh """
        redis-cli EVAL "if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end" 1 ${lockKey} ${lockValue}
    """
}

pipeline {
    agent { label 'NodeA' }
    stages {
        stage('Acquire Lock') {
            steps {
                script {
                    def lockValue = acquireLock()
                    if (!lockValue) {
                        error "NodeA is locked by another Jenkins instance, aborting..."
                    }
                    // 可选：调用对方Jenkins API将NodeA设为离线
                    // 这里省略API调用代码
                    env.LOCK_VALUE = lockValue
                }
            }
        }
        stage('Build') {
            steps {
                echo 'Running build on NodeA...'
            }
        }
    }
    post {
        always {
            script {
                releaseLock(env.LOCK_VALUE)
                // 可选：恢复对方Jenkins的NodeA在线状态
            }
        }
    }
}

方案三：基于节点本地锁文件的轻量方案 #

如果不想引入外部服务，也可以直接在Node A上创建锁文件来实现互斥：

• 当Jenkins实例要使用Node A时，先检查Node A上是否存在指定的锁文件（比如/var/jenkins/nodeA.lock）
• 如果不存在，就创建锁文件并写入当前Jenkins实例标识和时间戳；如果存在，就退出任务或者等待
• 任务完成后删除锁文件

注意事项： #

• 要处理锁文件残留的问题（比如Jenkins实例崩溃没删除锁），可以在检查锁文件时判断时间戳，如果超过一定时长就强制删除
• 这种方式依赖Node A的文件系统，适合节点可控的场景

关键注意点 #

• 无论哪种方案，都要考虑故障恢复：比如某个Jenkins实例崩溃后，要确保Node A能被自动释放，避免永久离线
• 建议给Node A配置任务超时时间，防止长时间占用节点
• 测试时要模拟各种异常场景（比如实例宕机、网络中断），确保方案的稳定性

内容的提问来源于stack exchange，提问作者Tin Topolovec