.NET Core QuartzJob定时任务+Windows/Linux部署

Posted DotNet

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了.NET Core QuartzJob定时任务+Windows/Linux部署相关的知识,希望对你有一定的参考价值。


(给DotNet加星标,提升.Net技能

转自:gt1987
cnblogs.com/gt1987/p/13921162.html

前言


以前总结过一篇基于Quartz+Topshelf+.NET Core实现定时任务Windows服务 https://www.cnblogs.com/gt1987/p/11806053.html。


回顾起来发现有点野路子的感觉,没有使用.NET Core推荐的基于HostedService的方式,也没有体现.NET Core跨平台的风格。于是重新写了一个Sample。


Work Service


首先搭建项目框架。


  • 版本 .NET Core3.1


  • 建立一个Console程序项目模板,修改 project 属性为 <Project Sdk="Microsoft.NET.Sdk.Worker">。


  • Nuget引入 Microsoft.Extensions.Hosting,支持配置+Logging+注入等基本框架内容。


  • Nuget引入 Quartz.Jobs 组件。


后来发现vs2019实际有一个 Worker Service 项目模板,直接选择建立即可,不用上面这么麻烦~~


QuartzJob、HostedService集成


集成的主要思路为以 HostedService 作为服务承载,启动的时候 加载 QuartzJob 定时任务配置并启动。而 HostedService 则自动接入.NET Core服务程序体系。


由于 QuartzJob 暂没有专门的..NET Core版本,这里我们首先要作下特别处理,实现一个JobFactory用于集成.net core依赖注入框架。


public class MyJobFactory : IJobFactory
{
private readonly IServiceProvider _serviceProvider;
public MyJobFactory(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
}
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
{
return _serviceProvider.GetRequiredService(bundle.JobDetail.JobType) as IJob;
}
public void ReturnJob(IJob job)
{
//IJob已经在.net core容器体系下,应该考虑通过DI的方式 dispose
//IJob对象的销毁 if implement IDisposable
//var dispose = job as IDisposable;
//dispose?.Dispose();
}
}


定义一个SampleJob:


[DisallowConcurrentExecution]public class SampleJob : IJob
{
private readonly ILogger<SampleJob> _logger;
public SampleJob(ILogger<SampleJob> logger)
{
_logger = logger;
}
public void Dispose()
{
_logger.LogInformation($"{nameof(SampleJob)} disposed.");
}
public async Task Execute(IJobExecutionContext context)
{
_logger.LogInformation($"{nameof(SampleJob)} executed at {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
await Task.CompletedTask;
}
}


定义自己的HostedService,在Start方法里面配置了定时任务并启动


public class QuartzJobHostedService : IHostedService
{
private readonly IScheduler _scheduler;
private readonly ILogger<QuartzJobHostedService> _logger;
public QuartzJobHostedService(IScheduler scheduler,
ILogger<QuartzJobHostedService> logger
)
{
_scheduler = scheduler;
_logger = logger;
}
public async Task StartAsync(CancellationToken cancellationToken)
{
//just for sample test,should configuration in config file when dev
//sample job
var job = CreateJob(typeof(SampleJob));
var trigger = CreateTrigger("SampleJob", "0/5 * * * * ?");
await _scheduler.ScheduleJob(job, trigger, cancellationToken);
//disposed job
var job2 = CreateJob(typeof(DisposedSampleJob));
var trigger2 = CreateTrigger("DisposeSampleJob", "0/10 * * * * ?");
await _scheduler.ScheduleJob(job2, trigger2, cancellationToken);
await _scheduler.Start(cancellationToken);
_logger.LogInformation("jobScheduler started.");
}
public async Task StopAsync(CancellationToken cancellationToken)
{
await _scheduler?.Shutdown(cancellationToken);
_logger.LogInformation("jobScheduler stoped.");
}
private ITrigger CreateTrigger(string name, string cronExpression)
{
return TriggerBuilder
.Create()
.WithIdentity($"{name}.trigger")
.WithCronSchedule(cronExpression)
.Build();
}
private IJobDetail CreateJob(Type jobType)
{
return JobBuilder
.Create(jobType)
.WithIdentity(jobType.FullName)
.WithDescription(jobType.Name)
.Build();
}
}


最后我们看一下服务的启动配置,注意IScheduler和IJobFactory的生命周期,这里由于 StdSchedulerFactory.GetDefaultScheduler() 的原因,必须是Singleton来兼容。


class Program
{
static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
host.Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>Microsoft.Extensions.Hosting.Host.CreateDefaultBuilder(args)
.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.AddConsole();
loggingBuilder.SetMinimumLevel(LogLevel.Information);
})
.ConfigureServices((context, services) =>
{
services.AddTransient<SampleJob>()
.AddTransient<DisposedSampleJob>()
.AddTransient<IDisposableService, DisposableService>()
.AddSingleton<IJobFactory, MyJobFactory>()
.AddSingleton<IScheduler>(sp =>
{
var scheduler = StdSchedulerFactory.GetDefaultScheduler().ConfigureAwait(false).GetAwaiter().GetResult();
scheduler.JobFactory = sp.GetRequiredService<IJobFactory>();
return scheduler;
})
.AddHostedService<QuartzJobHostedService>();
})
//if install by topshelf,don't need this
.UseWindowsService();
}


这样一个简单的定时任务服务就搭建完成了,可以本地启动运行。但是如果要部署到服务器上作为windows服务或者linux服务,还需要作一点额外的工作。


IDisposable 问题


这里插入另外一个话题,我们看到 IJobFactory 有一个 ReturnJob 方法用于处理Job对象的资源释放问题。但是我们知道在.NET Core依赖注入体系下,任何通过注入获取的对象一定不能通过自己手动方式来处理资源释放问题。


参考官方文档 

https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-3.1#design-services-for-dependency-injection。


那么如何处理需要手动释放例如 IDisposable 的问题呢?


这里我们建立一个继承 IDisposable 接口服务


//通常情况下 不应该将IDisposebale接口 注册为 Transient or Scope。改用工厂模式创建public interface IDisposableService : IDisposable{

}
public class DisposableService : IDisposableService
{
private ILogger<DisposableService> _logger;
public DisposableService(ILogger<DisposableService> logger)
{
_logger = logger;
}
public void Dispose()
{
_logger.LogInformation($"{nameof(DisposableService)} has disposed at {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}.");
}
}


依赖IDisposableService的SampleJob:


/// <summary>
/// 需要dispose
/// 1.IDisposableService可以注册为Singleton,会自动dispose
/// 2.如果不能注册单例,则如本例方式通过IServiceProvider.CreateScope方式处理
/// </summary>
[DisallowConcurrentExecution]
public class DisposedSampleJob : IJob
{
private readonly ILogger<DisposedSampleJob> _logger;
private readonly IServiceProvider _serviceProvider;
public DisposedSampleJob(ILogger<DisposedSampleJob> logger,
IServiceProvider serviceProvider
)
{
_logger = logger;
_serviceProvider = serviceProvider;
}
public async Task Execute(IJobExecutionContext context)
{
//if IDisposableService register Transient,use CreateScope to dispose IDisposableService
//if IDisposableService register singleton,it can be inject directly and dispose automatically
using (var scope = _serviceProvider.CreateScope())
{
var service = scope.ServiceProvider.GetRequiredService<IDisposableService>();
_logger.LogInformation($"{nameof(DisposedSampleJob)} executed at {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}.");
await Task.CompletedTask;
}
}
}


这里如注释,要么将 IDisposableService 注册为单例,直接注入引用,.NET Core DI框架会自动处理资源释放。如果某些原因不能注册单例,则需要采取不太推荐的 定位器模式,如上面代码中实现方式来处理。


部署windows服务


如果要部署到windows服务,则还需要引入 Microsoft.Extensions.Hosting.WindowsServices组件,在构建 IHostBuilder的时候加入 UseWindowsService()即可。


它主要的功能是将整个系统的生命周期接入windows服务的生命周期。(默认的是console控制台程序生命周期)。


然后就是烦人的部署到windows服务。这里提供了install和uninstall2个脚本,使用的是window sc工具。


install.bat


set serviceName=QuartzJob.Sample.JobService
set serviceFilePath=F:\gt_work\MyProject\git_project\gt.SomeSamples\QuartzJob.Sample\bin\Release\netcoreapp3.1\QuartzJob.Sample.exe
set serviceDescription=sample job

sc create %serviceName% BinPath=%serviceFilePath%
sc config %serviceName% start=auto
sc description %serviceName% %serviceDescription%
sc start %serviceName%
pause


uninstall.bat


set serviceName=QuartzJob.Sample.JobService
sc stop %serviceName%
sc delete %serviceName%
pause


通过管理员权限启动即可正常部署和卸载windows服务


部署Linux服务


如果要部署到Linux服务的话,我查到的有两种方式,一种是Systemd方式,需要引入 Microsoft.Extensions.Hosting.Systemd组件,加入 UseSystemd。另一种方式使用SuperVisor来创建服务。这里我尝试使用了SuperVisor来实现。


我的Linux版本是Centos7,这里刚开始我找了一台Centos6的机器,在安装.netcore sdk这步就走不下去了,这里注意下。


  • 注册microsoft密钥 sudo rpm -Uvh https://packages.microsoft.com/config/centos/7/packages-microsoft-prod.rpm


  • 安装.netcore sudo yum install dotnet-sdk-3.1


  • 安装SuperVisor yum install -y supervisor,这里也许要安装依赖 yum install epel-release


  • 配置启动,在/etc/supervisord.d/ 新建 QuartzJob.Sample.ini 配置文件。directory指向到发布包目录。


[program:QuartzJob.Sample]
command=dotnet QuartzJob.Sample.dll
directory=/root/gt/QuartzJob.Sample
environment=ASPNETCORE__ENVIRONMENT=Production
user=root
stopsignal=INT
autostart=false
autorestart=false
startsecs=1
stderr_logfile=/var/log/quartzJob.err.log
stdout_logfile=/var/log/quartzJob.out.log


这么做的原因可以查看 /etc/supervisord.conf 配置中这一段 files=supervisord.d/*ini,表示默认加载启动supervisord.d目录下的 .ini文件配置


  • 启动SuperVisor,sudo service supervisord start。服务正常启动


集成Topshelf


Topshelf组件在framework时代是一款非常方便生成服务windows服务的工具,可以通过代码的方式配置并生成windows服务。可惜目前没有看到.netcore的配合版本。且由于依赖windows系统,似乎不太切合.netcore跨平台的特性。这里给出集成的方式,只适用windows平台。


install 命令:


.\QuartzJob.Sample.exe install
.\QuartzJob.Sample.exe start


uninstall 命令:


.\QuartzJob.Sample.exe stop
.\QuartzJob.Sample.exe uninstall


这里的原理就是用Topshelf的Host替代.netcore的Host,在Topshelf Host启动时再启动.netcore Host。反正看着很变扭。


另外特别注意 s.WhenStarted(tc => tc.StartAsync()); 这里使用的是StartAsync方法而不是Start方法,因为Start方法是同步堵塞的,在部署到windows服务时,由于这一步堵塞,会导致windows服务一直卡在启动状态直至超时启动失败。 


- EOF -



推荐阅读   点击标题可跳转


看完本文有收获?请转发分享给更多人

关注「DotNet」加星标,提升.Net技能 

好文章,我在看❤️

以上是关于.NET Core QuartzJob定时任务+Windows/Linux部署的主要内容,如果未能解决你的问题,请参考以下文章

ASP.NET Core2.2+Quartz.Net 实现web定时任务

asp.net core定时任务保持存活,不会被回收。asp.net core回收事件

2步轻松实现ASP.NET Core托管服务执行定时任务

C#/.NET/.NET Core应用程序编程中实现定时任务调度的方法或者组件有哪些,Timer,FluentScheduler,TaskScheduler,Gofer.NET,Coravel,Qua

.Net Core小技巧 - Hosted Services + Quartz实现定时任务调度

Asp-Net-Core开发笔记:集成Hangfire实现异步任务队列和定时任务