xxl-job跨集群调度改造

最新推荐文章于 2024-06-05 21:00:00 发布
最新推荐文章于 2024-06-05 21:00:00 发布
阅读量383 收藏 9
点赞数 5
文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41653901/article/details/138561308
版权

这篇文章为大家提供一种在多k8s集群中部署一套xxl-job的方案。

问题背景：

  1. 公司生产环境有多套k8s集群，为保证服务可用，容器需要部署到不同集群中。单集群中容器间可直接通过本地ip访问，跨集群容器间调用需通过宿主ip+映射端口访问。
  2. 由于k8s部署容器时不一定会在哪台宿主机，我们设定xxl-job执行器注册的ip为自动获取的本地ip，端口固定。admin使用的数据库为同一套，导致在跨集群情况下admin调度另一个k8s集群的executor会失败。
    如下图：
    在这里插入图片描述

目标：

  1. admin与executor能在所有集群中部署
  2. 不同集群中的admin能够调度所有的executor
  3. 保证任务调度策略（如轮询，第一个，故障转移，最近最久未使用，admin管理端指定ip调用）不受影响。
    在这里插入图片描述

解决思路

在admin中添加调度代理接口，利用不同k8s集群配置的ip网段差异，在admin调度时判断与executor网段是否一致，如果一致则直接调度，不一致则将调度请求（通过调度代理接口）交给与executor同集群的admin，由同集群admin调用执行器。
在这里插入图片描述

具体开发：

  1. 在admin中创建调度代理接口
    如上面架构图展示的，调度器通过http请求执行器接口完成调度，源码：
    com.xxl.job.core.biz.client.ExecutorBizClient
public class ExecutorBizClient implements ExecutorBiz {
.......
    private String addressUrl ;
    private String accessToken;
    private int timeout = 3;


    @Override
    public ReturnT<String> beat() {
        return XxlJobRemotingUtil.postBody(addressUrl+"beat", accessToken, timeout, "", String.class);
    }

    @Override
    public ReturnT<String> idleBeat(IdleBeatParam idleBeatParam){
        return XxlJobRemotingUtil.postBody(addressUrl+"idleBeat", accessToken, timeout, idleBeatParam, String.class);
    }

    @Override
    public ReturnT<String> run(TriggerParam triggerParam) {
        return XxlJobRemotingUtil.postBody(addressUrl + "run", accessToken, timeout, triggerParam, String.class);
    }
...........

所以先在xxl-job-admin中创建接收调度请求的代理接口：

package com.xxl.job.admin.controller;

@Controller
public class ProxyController {

    @RequestMapping(value = "health",method = RequestMethod.POST)
    @ResponseBody
    @PermissionLimit(limit = false)
    public ReturnT health(@RequestHeader(XxlJobRemotingUtil.XXL_JOB_ACCESS_TOKEN) String accessTokenReq,@RequestBody HealthParam healthParam) throws Exception {
        String accessToken = Config().getAccessToken();//这里是获取配置的accesstoken，请根据您自身获取accesstoken的方式进行修改
        if (accessToken != null
                && accessToken.trim().length() > 0
                && !accessToken.equals(accessTokenReq)) {
            return new ReturnT<String>(ReturnT.FAIL_CODE, "The access token is wrong.");
        }
        if(StringUtils.isBlank(healthParam.getAddressUrl())) return new ReturnT<String>(ReturnT.FAIL_CODE, "The addressUrl is wrong.");

        ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(healthParam.getAddressUrl());
        return executorBiz.health();
    }

    @RequestMapping(value = "beat",method = RequestMethod.POST)
    @ResponseBody
    @PermissionLimit(limit = false)
    public ReturnT beat(@RequestHeader(XxlJobRemotingUtil.XXL_JOB_ACCESS_TOKEN) String accessTokenReq,@RequestBody BeatParam beatParam) throws Exception {
        String accessToken = Config().getAccessToken();//这里是获取配置的accesstoken，请根据您自身获取accesstoken的方式进行修改
        if (accessToken != null
                && accessToken.trim().length() > 0
                && !accessToken.equals(accessTokenReq)) {
            return new ReturnT<String>(ReturnT.FAIL_CODE, "The access token is wrong.");
        }
        if(StringUtils.isBlank(beatParam.getAddressUrl())) return new ReturnT<String>(ReturnT.FAIL_CODE, "The addressUrl is wrong.");

        ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(beatParam.getAddressUrl());
        return executorBiz.beat();
    }

    @RequestMapping(value = "idleBeat",method = RequestMethod.POST)
    @ResponseBody
    @PermissionLimit(limit = false)
    public ReturnT idleBeat(@RequestHeader(XxlJobRemotingUtil.XXL_JOB_ACCESS_TOKEN) String accessTokenReq, @RequestBody IdleBeatParam idleBeatParam) throws Exception {
        String accessToken = Config().getAccessToken();//这里是获取配置的accesstoken，请根据您自身获取accesstoken的方式进行修改
        if (accessToken != null
                && accessToken.trim().length() > 0
                && !accessToken.equals(accessTokenReq)) {
            return new ReturnT<String>(ReturnT.FAIL_CODE, "The access token is wrong.");
        }
        if(StringUtils.isBlank(idleBeatParam.getAddressUrl())) return new ReturnT<String>(ReturnT.FAIL_CODE, "The addressUrl is wrong.");

        ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(idleBeatParam.getAddressUrl());
        return executorBiz.idleBeat(idleBeatParam);
    }
    @RequestMapping(value = "run",method = RequestMethod.POST)
    @ResponseBody
    @PermissionLimit(limit = false)
    public ReturnT run(@RequestHeader(XxlJobRemotingUtil.XXL_JOB_ACCESS_TOKEN) String accessTokenReq,@RequestBody TriggerParam triggerParam) throws Exception {
        String accessToken = Config().getAccessToken();//这里是获取配置的accesstoken，请根据您自身获取accesstoken的方式进行修改
        if (accessToken != null
                && accessToken.trim().length() > 0
                && !accessToken.equals(accessTokenReq)) {
            return new ReturnT<String>(ReturnT.FAIL_CODE, "The access token is wrong.");
        }
        if(StringUtils.isBlank(triggerParam.getAddressUrl())) return new ReturnT<String>(ReturnT.FAIL_CODE, "The addressUrl is wrong.");

        ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(triggerParam.getAddressUrl());
        return executorBiz.run(triggerParam);
    }
    @RequestMapping(value = "kill",method = RequestMethod.POST)
    @ResponseBody
    @PermissionLimit(limit = false)
    public ReturnT kill(@RequestHeader(XxlJobRemotingUtil.XXL_JOB_ACCESS_TOKEN) String accessTokenReq,@RequestBody KillParam killParam) throws Exception {
        String accessToken = Config().getAccessToken();//这里是获取配置的accesstoken，请根据您自身获取accesstoken的方式进行修改
        if (accessToken != null
                && accessToken.trim().length() > 0
                && !accessToken.equals(accessTokenReq)) {
            return new ReturnT<String>(ReturnT.FAIL_CODE, "The access token is wrong.");
        }
        if(StringUtils.isBlank(killParam.getAddressUrl())) return new ReturnT<String>(ReturnT.FAIL_CODE, "The addressUrl is wrong.");

        ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(killParam.getAddressUrl());
        return executorBiz.kill(killParam);
    }
    @RequestMapping(value = "log",method = RequestMethod.POST)
    @ResponseBody
    @PermissionLimit(limit = false)
    public ReturnT log(@RequestHeader(XxlJobRemotingUtil.XXL_JOB_ACCESS_TOKEN) String accessTokenReq,@RequestBody LogParam logParam) throws Exception {
        String accessToken = Config().getAccessToken();//这里是获取配置的accesstoken，请根据您自身获取accesstoken的方式进行修改
        if (accessToken != null
                && accessToken.trim().length() > 0
                && !accessToken.equals(accessTokenReq)) {
            return new ReturnT<String>(ReturnT.FAIL_CODE, "The access token is wrong.");
        }
        if(StringUtils.isBlank(logParam.getAddressUrl())) return new ReturnT<String>(ReturnT.FAIL_CODE, "The addressUrl is wrong.");

        ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(logParam.getAddressUrl());
        return executorBiz.log(logParam);
    }
}

其次我添加了一个请求参数的父类BaseParam，用于保存想要调度的executor ip。并让所有的请求参数继承自这个父类。

public class BaseParam {
    private String addressUrl;

    public String getAddressUrl() {
        return addressUrl;
    }

    public void setAddressUrl(String addressUrl) {
        this.addressUrl = addressUrl;
    }
}

public class TriggerParam extends BaseParam implements Serializable{
.....

其次要注意，要将代理接口的登录校验、鉴权关闭。

  1. 修改获取执行器信息逻辑：
    com.xxl.job.admin.core.trigger.XxlJobTrigger#runExecutor中获取调度器并调用执行器：
public class XxlJobTrigger {
.....
    /**
     * run executor
     * @param triggerParam
     * @param address
     * @return
     */
    public static ReturnT<String> runExecutor(TriggerParam triggerParam, String address){
        ReturnT<String> runResult = null;
        try {
            ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(address);//获取执行器信息，我们需要修改这里的逻辑
            runResult = executorBiz.run(triggerParam);//调用执行器
        } catch (Exception e) {
            logger.error(">>>>>>>>>>> xxl-job trigger error, please check if the executor[{}] is running.", address, e);
            runResult = new ReturnT<String>(ReturnT.FAIL_CODE, ThrowableUtil.toString(e));
        }

        StringBuffer runResultSB = new StringBuffer(I18nUtil.getString("jobconf_trigger_run") + "：");
        runResultSB.append("<br>address：").append(address);
        runResultSB.append("<br>code：").append(runResult.getCode());
        runResultSB.append("<br>msg：").append(runResult.getMsg());

        runResult.setMsg(runResultSB.toString());
        return runResult;
    }

}

原获取执行器的代码：

    public static ExecutorBiz getExecutorBiz(String address) throws Exception {
        // valid
        if (address==null || address.trim().length()==0) {
            return null;
        }

        // load-cache
        address = address.trim();
        ExecutorBiz executorBiz = executorBizRepository.get(address);
        if (executorBiz != null) {
            return executorBiz;
        }

        // set-cache
        executorBiz = new ExecutorBizClient(address, XxlJobAdminConfig.getAdminConfig().getAccessToken());

        executorBizRepository.put(address, executorBiz);
        return executorBiz;
    }

添加代理逻辑：

public static ExecutorBiz getExecutorBiz(String localAddressUrl) throws Exception {
        // valid
        if (localAddressUrl == null || localAddressUrl.trim().length() == 0) {
            return null;
        }

        // load-cache
        localAddressUrl = localAddressUrl.trim();
        ExecutorBiz executorBiz = executorBizRepository.get(localAddressUrl);
        if (executorBiz != null) {
            return executorBiz;
        }

        // set-cache
        //添加代理：
        String addressUrl = getProxyAddress(localAddressUrl);
        executorBiz = new ExecutorBizClient(addressUrl,localAddressUrl, JobAdminConfig.getAdminConfig().getAccessToken());

        executorBizRepository.put(localAddressUrl, executorBiz);
        return executorBiz;
    }

    /**
     * 判断执行器与当前admin是否同一网段，是则原address返回，不是则返回代理（与目标执行器同网段）admin的k8s映射地址+端口地址
     * @param address
     * @return
     * @throws UnknownHostException
     */
    private static String getProxyAddress(String address) throws UnknownHostException {
        InetAddress localhost = InetAddress.getLocalHost();
        String hostAddress = localhost.getHostAddress();
        String segment = address.split("\\.")[0].replace("http://", "");
        Config config = Config().getConfig();//这里是获取不同集群网段内admin的映射地址配置，json格式字符串
        String adminProxyAddress = config.getProperty("adminProxyAddress", "");
        if(!(StringUtils.isAnyBlank(hostAddress,adminProxyAddress) || hostAddress.split("\\.")[0].equals(segment))){
            JSONObject jsonObject = JSONObject.parseObject(adminProxyAddress);
            String proxyAddress = jsonObject.getString(segment);
            if(StringUtils.isNotBlank(proxyAddress)){
                String[] split = proxyAddress.split(",");
                Random random = new Random();
                int randomNumber = random.nextInt(split.length);//集群内有多个容器，这里地址随机取
                return split[randomNumber];
            }
        }
        return address;
    }

ExecutorBizClient中添加本地executor地址：localAddressUrl

public class ExecutorBizClient implements ExecutorBiz {

    public ExecutorBizClient() {
    }

    public ExecutorBizClient(String addressUrl,String localAddressUrl,String accessToken) {
        this.addressUrl = addressUrl;
        this.accessToken = accessToken;
        this.localAddressUrl = localAddressUrl;
        // valid
        if (!this.addressUrl.endsWith("/")) {
            this.addressUrl = this.addressUrl + "/";
        }
        if (!this.localAddressUrl.endsWith("/")) {
            this.localAddressUrl = this.localAddressUrl + "/";
        }
    }
    //执行器调用地址，同一网段下addressUrl=localAddressUrl，不同网段下addressUrl为代理地址
    private String addressUrl;
    //同网段执行器调用地址localAddressUrl，是原addressUrl的含义
    private String localAddressUrl;
    private String accessToken;
    private int timeout = 4;//这里因为走代理多了一次转发，所以容易出现调度接口超时，超时时间需要看情况增加，不改也行，不影响执行

这样就完成了xxl-job的跨集群改造

小林子你真猛！
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
xxl-job分布式任务调度平台-其他
06-12
XXL-JOB是一个轻量级分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。 XXL-JOB特点： 1、简单：支持通过Web页面对任务进行CRUD操作，...
解决k8s中xxl-job执行器pod重建后无法读取到执行日志的问题
08-24
xxl-job-admin读取执行日志的逻辑为：向执行了该任务的执行器发送请求，让执行器从本地读取执行日志。但在k8s中，即使将本地文件通过nfs独立存储，在pod重建后也通常会因为ip变更，找不到执行器，导致读取不到执行...
xxl-job调度中心集群部署重复调度问题
gttoi
05-10 6032
这里写自定义目录标题项目场景：问题描述：原因分析：解决方案： 项目场景： 公司原有一台定时调度服务器，后添加了一台服务器，两台服务器用的同一套数据库 问题描述： 因存在两台调度中心，顾思考是否会产出重复调度的问题，于是查看源码，调度中心源码实现如下，只贴出部分 原因分析： 根据上述代码可见，采用了数据库for update获取行锁，来保证同一时间只有一台服务器可查询需要执行的任务，及调度，但是问题出现了，不同服务器之间，时间几乎做不到完全同步的，若是两台服务器时间不同步，是否会产生重复调度的问
工具篇-- 定时任务xxl-job的集群部署
拽着尾巴的鱼儿的博客
02-26 2183
xxl-job 中xxl-job-admin 和 xxl-job-executor-samples 集群部署；本文介绍xxljob 调度端以及执行器端 的集群，以及任务执行执行时的负载均衡和故障转移。
Docker部署Xxl-Job分布式任务调度中心(超详细)
热门推荐
qq_35716689的博客
01-20 35万+
本文详细的讲解了如何使用Docker部署xxl-job分布式任务调度服务，XXL-Job是一个开源的分布式任务调度中心。作者：鼠鼠我捏，要死了捏
SpringCloud-搭建XXL-JOB任务调度平台教程
踏雨歌青春，诗酒趁年华
04-21 7875
本教程提供了从XXL-JOB平台介绍到具体搭建流程的详细说明，旨在帮助开发者和系统管理员快速理解和部署XXL-JOB任务调度平台。通过Spring Cloud集成XXL-JOB任务调度平台，可以使微服务环境中的任务调度更加灵活和高效。整个过程中，调度中心和执行器的正确配置是关键。此外，通过XXL-JOB提供的控制台，用户可以轻松管理和监控任务的运行状态，实现任务的高效执行。
【分布式任务调度】（一）XXL-JOB调度中心集群部署配置
积木成林，聚沙成塔
10-20 8601
XXL-JOB是一款轻量级的分布式任务调度中间件，默认支持6000个定时任务，如果生产环境的任务数量在这个范围内，可以选择使用 XXL-JOB。操作更简单，学习成本更低使用异步化调度，性能更好有配套的运维后台系统，提供了配置、监控、日志、统计报表等功能拥有更简单的集群部署方案，服务的注册与发现等功能详情参考《官方文档》本文的内容在官方文档上都可以找到，只是在这基础上做了一点细节补充，有经验的同学可以直接查阅官方文档。多个节点使用同一个数据库。多台机器的系统时间配置成一样的。
xxl-job分布式任务调度器的学习
飞鸟的心情
07-22 144
先看一下原生的任务调度器定时任务调度器在什么场景下使用呢？房贷车贷的还款，花呗借呗白条的还款等等这种参加定时活动的场景。原生的任务调度器有什么弊端呢？1.在分布式环境下，每个应用都配一个任务调度器的话那么执行多次；2.如果任务执行失败了，不能重试；执行异常了，不能报警；3.重新配置了任务的话，必须要重启应用 等等。所以需要选择一种机制进行定时调度，那就选择xxl-job，是中国人开发，完整的中文文档，低门槛，易于管理。这里选择GITEE下载，下载到本地的代码中有sql，doc，源码等等，
XXL-JOB分布式任务调度框架(三)-集群部署
学习交流，答疑解惑，可以查看博客主页左侧我的推广哦！
02-20 1076
XXL-JOB是一个开源的，具有丰富的任务管理功能以及高性能，高可用等特点的轻量级分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展、开箱即用！！！ 于2015问世，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。
【分布式任务调度】（四）XXL-JOB的任务调度执行流程及实现原理
积木成林，聚沙成塔
10-29 2万+
调度中心调用执行器，执行定时任务。执行器回调调度中心，上报定时任务执行结果。在调度和执行的整个流程中，XXL-JOB使用了大量的异步操作，减少调度中心的资源压力，以此在集中式调度配置与性能之间找到平衡点。异步实践通过线程池来执行异步操作通过自旋线程 + 阻塞队列的方式来执行异步操作。
XXL-JOB分布式任务调度平台
初八
11-20 1245
XXL-JOB分布式任务调度平台（保姆级别的教程，包教包会）
xxl-job任务调度中心集群部署详细文档
01-19
1、XXL-JOB调度中心集群部署要求 2、Nginx负载均衡配置 3、解决xxl-job集群重复执行任务问题
XXL-JOB分布式任务调度平台源码
05-24
XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。 特性：1、简单：支持通过Web页面对任务进行CRUD操作，操作简单，一...
xxl-job:xxl-job二次开发 定时任务，增加API接口添加任务、删除任务等操作
05-16
XXL-JOB是一个轻量级分布式任务调度框架，其核心设计目标是开发Swift、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。 Documentation 二次开发内容 1、数据库连接池修改为druid 2、...
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1556
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
JavaScript第九讲：BOM编程
星途码客的博客
06-04 790
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
设计模式之装饰器模式
最新发布
丿微风乍起的博客
06-05 579
装饰器模式是一种结构型设计模式，它允许我们在不改变原有对象结构的情况下，动态地给对象增加一些职责（即增加其额外功能）。其核心在于通过组合而非继承的方式来扩展对象的功能。Component: 这是抽象组件接口，所有的具体组件和装饰器都必须实现这个接口。Concrete Component: 具体组件，这是我们要装饰的基本对象，它实现了Component接口。Decorator: 抽象装饰器，也是实现Component接口的，它包含一个对Component类型的引用，通常在构造函数中初始化。
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
Itmastergo的博客
05-31 999
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
xxl-job分片调度
09-16
引用中提到，如果我们希望在一个任务执行成功后触发另一个任务，可以将另一个任务作为本任务的子任务运行。只需要在本任务中填入另一个任务的jobId即可。同时，引用还介绍了xxl-job中的阻塞处理策略，包括单机串行、FIFO丢弃后续调度和覆盖之前调度等策略。 引用中的代码演示了如何在xxl-job中实现单个任务和集群任务。代码中使用注解@XxlJob标识任务，并提供了执行方法execute。在方法中，可以编写具体的任务逻辑，比如遍历ID列表，执行对应的业务逻辑。 引用中提到了xxl-job的分片调度。对于顺序ID（自增ID），可以使用取模方式实现均匀分派分片数。然而，对于范围分片（时间段分片），xxl-job并没有提供类似的分片算法。根据实际项目情况，可以根据需要自定义分片算法，或者选择不使用分片算法。如果不使用分片算法，那么单例job与普通任务没有太大区别。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值