How to self register a service with Consul
Startup.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
namespace WebApplication1
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddConsulConfig(Configuration);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseConsul();
app.UseMvc();
}
}
}
AppExtensions.cs
using Consul;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace WebApplication1
{
public static class AppExtensions
{
public static IServiceCollection AddConsulConfig(this IServiceCollection services, IConfiguration configuration)
{
services.AddSingleton<IConsulClient, ConsulClient>(p => new ConsulClient(consulConfig =>
{
var address = configuration.GetValue<string>("http://localhost:8500");
consulConfig.Address = new Uri(address);
}));
return services;
}
public static IApplicationBuilder UseConsul(this IApplicationBuilder app)
{
var consulClient = app.ApplicationServices.GetRequiredService<IConsulClient>();
var logger = app.ApplicationServices.GetRequiredService<ILoggerFactory>().CreateLogger("AppExtensions");
var lifetime = app.ApplicationServices.GetRequiredService<IApplicationLifetime>();
// var uri = new Uri(address);
// Better approach should be used to set the below settings. I hard coded just to explain.
var registration = new AgentServiceRegistration()
{
ID = $"MyService",
Name = "WebApplication1",
Address = "localhost", //$"{uri.Host}",
Port = 57084 // uri.Port
};
logger.LogInformation("Registering with Consul");
consulClient.Agent.ServiceDeregister(registration.ID).ConfigureAwait(true);
consulClient.Agent.ServiceRegister(registration).ConfigureAwait(true);
lifetime.ApplicationStopping.Register(() =>
{
logger.LogInformation("Unregistering from Consul");
consulClient.Agent.ServiceDeregister(registration.ID).ConfigureAwait(true);
});
return app;
}
}
}
Github repo
First of all I recommend to use Consul.NET to interact with Consul. Using it, a service registration may look like:
var registration = new AgentServiceRegistration
{
Name = "foo",
Port = 4242,
Address = "http://bar"
};
using (var client = new ConsulClient())
{
await client.Agent.ServiceRegister(registration);
}
Now let's integrate this code into ASP.NET Core startup process with help of DI and loose coupling. Read your json file into ConsulOptions
instance (DTO without any logic):
public void ConfigureServices(IServiceCollection services)
{
services.AddOptions();
services.Configure<ConsulOptions>(Configuration);
}
Encapsulate all Consul-related logic in class ConsulService
accepting ConsulOptions
as a dependency:
public class ConsulService : IDisposable
{
public ConsulService(IOptions<ConsulOptions> optAccessor) { }
public void Register()
{
//possible implementation of synchronous API
client.Agent.ServiceRegister(registration).GetAwaiter().GetResult();
}
}
Add the class itself to the DI container:
services.AddTransient<ConsulService>();
Then create an extention method of IApplicationBuilder
and call it:
public void Configure(IApplicationBuilder app)
{
app.ConsulRegister();
}
In ConsulRegister
implementation we add our hooks on application start/stop:
public static class ApplicationBuilderExtensions
{
public static ConsulService Service { get; set; }
public static IApplicationBuilder ConsulRegister(this IApplicationBuilder app)
{
//design ConsulService class as long-lived or store ApplicationServices instead
Service = app.ApplicationServices.GetService<ConsulService>();
var life = app.ApplicationServices.GetService<IApplicationLifetime>();
life.ApplicationStarted.Register(OnStarted);
life.ApplicationStopping.Register(OnStopping);
return app;
}
private static void OnStarted()
{
Service.Register(); //finally, register the API in Consul
}
}
Locking absence and static fields are OK because the Startup
class is executed exactly once on application start. Don't forget to de-register the API in OnStopping
method!