.NET

29 jul, 2020

Construindo um Windows Service ou Linux Daemon com Worker Service & .NET Core – Parte 2

100 visualizações
Publicidade

Fala Galera,

Continuando a série dos Workers Services, nesta parte final do nosso post, vou trazer como podemos criar um Worker Service no Linux.

Desejar criar um Worker Service no Windows? Dê uma lida na parte 1 clicando aqui

Recap: O que é um Worker Service?

É um modelo do .NET Core que permite criar serviços em segundo plano (background) para processamentos contínuo ou agendados. Esses serviços em background implementam a interface IHostedService e podem ser implantados como um serviço do Windows, mas também podemos implantar como daemons do Linux. Isso é muito legal. Neste post, veremos como criar e implantar um Worker Service como um Serviço do Linux.

Recap: Aonde utilizamos?

Os serviços em background são perfeito para qualquer processamento em segundo plano, como processamento de mensagens de uma fila Kafka, RabbitMQ, SQS, Azure Service Bus, processamento de um arquivo de retorno em caso de compras online com pagamento em boleto entre outros cenários. E para esses cenários em que precisamos criar serviços em background, o .NET Core traz um recurso muito interessante: Worker Service.

Criando um Work Service

Em seu prompt de comando favorito, digite “dotnet new worker” ou na tela inicial do Visual Studio escolha Work Service conforme imagem abaixo:

“”

Com o template criado, abra o program.cs. Ele exibirá um código semelhante com o código abaixo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace Workers_linux
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }
        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddHostedService<Worker>();
                });
    }
}

Trabalhando com o Linux:

Para que possamos rodar nossos workers em background no Linux devemos adicionar o pacote Microsoft.Extensions.Hosting.Systemd” com ele instalado, vamos poder utilizar o systemctl para trabalhar com processos em background. O Linux que eu escolhi para os testes foram o Ubuntu 20.04 LTS

Adicione o pacote com o comando “dotnet add package Microsoft.Extensions.Hosting.Systemd” ou adicione utilizando o Visual Studio Manager Nuget Package.

Após a instalação do pacote, abra o program.cs e adicione o “UseSystemd” o conforme mostrado abaixo:

public static IHostBuilder CreateHostBuilder(string[] args) =>
           Host.CreateDefaultBuilder(args)
               .UseSystemd()
               .ConfigureServices((hostContext, services) =>
               {
                   services.AddHostedService<Worker>();
               });

Criando o Arquivo Unit File

Estamos com o nosso serviço pronto, devemos informar ao systemctl como executá-lo. No prompt de comando do Linux, vá até a pasta /etc/systemd/system. Crie um arquivo com o final .service. Neste meu exemplo eu criei um arquivo chamado work.dotnet.service, a configuração do serviço deverá ser parecida com essa.

[Unit]
Description=Worker .NET

[Service]
Type=notify
ExecStart=/usr/bin/dotnet /home/rbcruz/source/workers/bin/Debug/netcoreapp3.1/workers.dll

[Install]
WantedBy=multi-user.target

Execute o comando sudo systemctl daemon-reload”, com este comando sendo executado, o systemctl irá carregar as novas configurações que acabamos de criar.

Para iniciar o nosso serviço, execute:

  • sudo systemctl start work.dotnet.service

Para parar o nosso serviço, execute:

  • sudo systemctl stop work.dotnet.service

Para habilitar no startup do sistema operacional, execute:

  • sudo systemctl enable work.dotnet.service

Para verificar o status do nosso serviço, execute:

  • sudo systemctl status work.dotnet.service

Veja as imagens do nosso serviço rodando no Linux.

Conclusão

Quando precisamos executar tarefas em background para processamentos longos, a melhor maneira é criarmos serviços em background para isso. Esses serviços em background são chamados de Work Service no .NET Core. Neste post vimos como criar um Work Service e como fazer as configurações como Systemd no Linux. Assim chegamos ao final de nossa série sobre Worker Service. E aí o que acharam, comenta aí =]

Abs e até a próxima