Microservicios en .NET Core 3.1
Tags: dotnetcore, microservicios
Published: 2020-03-07 00:02:49

---
title: Microservicios en .NET Core 3.1
published: true
date: 2020-03-06 20:06:47 UTC
tags: dotnet core, microservicios
canonical_url: https://yorodm.github.io/blog/microservices-dotnet-3/
---

La nueva versión LTS de .NET Core trae consigo muchas ventajas para ellos desarrolladores de microservicios. Una de las más esperadas es laestabilización de la API para ejecutar servicios en segundo plano o_workers_ utilizando `Microsoft.Extensions.Hosting`

## ¿Qué son los workers?

Si eres desarrollador de ASP.NET Core debes estar familiarizado con elpaquete `Microsoft.AspNetCore.Hosting` y las clases`WebHostBuilder` y`WebHost`.

```
public class Program
{
    public static void Main(string[] args)
    {
       var config = new ConfigurationBuilder()
            .AddCommandLine(args)
            .AddJsonFile("hosting.json", optional: true)
            .AddEnvironmentVariables()
            .Build();
      var host = new WebHostBuilder()
           .UseKestrel()
           .UseContentRoot(Directory.GetCurrentDirectory())
           .UseConfiguration(config)
           .Build();

       host.Run();
    }
 }
```

`WebHost` es responsable de iniciar la configuración, manejar el ciclode vida de los servicios, mantener el contenedor de dependencias ycomunicarse/iniciar el servidor web (Kestrel en este caso).

`WebHost` también nos brinda la posibilidad de iniciar servicios ensegundo plano utilizando `IHostedService`.

Si no estás familiarizado con el tema, puedes informarte más con [este excelente post](https://www.stevejgordon.co.uk/asp-net-core-2-ihostedservice "Implementing IHostedService in ASP.NET Core 2.0")

## Microservicios en aplicaciones de consola.

El nuevo host genérico (`HostBuilder`) no requiere de la maquinaria deASP.NET Core, lo cual hace posible crear aplicaciones de consola quehagan uso de las bondades a las que estamos adaptados.

Veamos un ejemplo:

```
 public class Program
    {
        public static void Main(string[] args)
        {
            try {
            CreateHostBuilder(args).Build().Run();
            }
            catch(OperationCanceledException ex)
            {
                Console.WriteLine("-----Terminating-----");
            }
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureAppConfiguration((hostingContext, config) =>
                {
                    var env = hostingContext.HostingEnvironment.EnvironmentName;
                    var builder = new ConfigurationBuilder()
                            .SetBasePath(Directory.GetCurrentDirectory())
                            .AddJsonFile("settings.json")
                            .AddEnvironmentVariables()
                            .Build();
                })
                .ConfigureServices((hostingContext, services) =>
                {

                    // AWS Configuration
                    var options = hostingContext.Configuration.GetAWSOptions();
                    services.AddDefaultAWSOptions(options);
                    services.AddAWSService<IAmazonSQS>();

                    // Worker Service
                    services.AddHostedService<Worker>();
                    services.AddLogging();

                }).ConfigureLogging((hostcontext, configLogging) =>
                {
                    configLogging.AddConsole();
                    configLogging.AddDebug();
                });
    }
```

El programa anterios hace uso del host genérico para:

1. Cargar la configuración externa (variables de entorno y archivo json).
2. Inicializar un servicio para acceder a SQS.
3. Configurar logs para la consola.
4. Crear un servicio en segundo plano.

La clase `Worker` hereda de `BackgroundService` y es la encargada deejecutar la lógica de nuestro microservicio

```
public class Worker: BackgroundService {

     public Worker(ILogger<Worker> logger, IAmazonSQS sqs)
        {
            _logger = logger;
            _sqs = sqs;
        }

     protected async Task ExecuteAsync(int number, CancellationToken cancel)
       {
            while (!cancel.IsCancellationRequested)
            {
                // Procesar mensajes desde SQS
            }
       }
}
```

## Integración con el sistema operativo

Si desarrollas servicios monolíticos o para software legado, puedeshacer uso del host genérico para integrar tu aplicación al sistemaoperativo.

Para integrarse como servicio a Windows se puede utilizar lasextensiones en `Microsoft.Extensions.Hosting.WindowsService` parainicializar nuestro programa.

```
 Host.CreateDefaultBuilder(args)
        .UseWindowsService()
```

En el casos de Linux sólo están soportadas las distribuciones que incluyen`Systemd`

```
  Host.CreateDefaultBuilder(args)
        .UseSystemd()
```