.NET Service Discovery

Introduction

Service discovery is a critical component in modern distributed systems, particularly in microservices architectures. It solves the problem of how services can find and communicate with each other without hardcoding network locations. In traditional monolithic applications, components typically communicate through in-memory function calls, but in a distributed system, services need to locate each other over a network.

In this guide, we'll explore service discovery concepts in .NET, understand why it's crucial, and learn how to implement it using various approaches and libraries.

What is Service Discovery?

Service discovery is a mechanism that allows services to locate each other dynamically over a network. It involves:

Registration: Services register themselves when they start
Discovery: Services find other services when they need to communicate
Health monitoring: Tracking which services are available and healthy

This process becomes essential when you have:

Dynamic IP addresses (especially in cloud environments)
Auto-scaling services (instances coming and going)
Services that move between hosts
Container-based deployments

Service Discovery Patterns in .NET

Client-Side Discovery

In this pattern, the client service is responsible for determining the network locations of available service instances and load-balancing requests across them.

Here's a simple example using a basic client-side approach:

csharp
public class SimpleClientSideDiscovery
{
    private readonly List<string> _serviceInstances = new List<string>
    {
        "https://service1-instance1:5001",
        "https://service1-instance2:5002",
        "https://service1-instance3:5003"
    };

    private int _currentIndex = 0;

    public string GetServiceInstance()
    {
        // Simple round-robin load balancing
        lock (this)
        {
            if (_currentIndex >= _serviceInstances.Count)
                _currentIndex = 0;
                
            return _serviceInstances[_currentIndex++];
        }
    }
}

// Usage
var discovery = new SimpleClientSideDiscovery();
var serviceUrl = discovery.GetServiceInstance();
// Now use the serviceUrl to make a request

Server-Side Discovery

In this pattern, clients make requests to a load balancer, which then forwards the request to an available service instance.

This is often implemented using reverse proxies like NGINX, HAProxy, or cloud-based load balancers, so there isn't much .NET-specific code. Your .NET services simply register themselves with the discovery service.

Implementing Service Discovery in .NET

Using Consul with .NET

Consul is a popular service discovery tool that integrates well with .NET applications.

First, install the NuGet package:

bash
dotnet add package Consul

Registering a Service with Consul

csharp
using Consul;

public static class ConsulRegistrationExtensions
{
    public static IHost UseConsul(this IHost host)
    {
        var consulClient = new ConsulClient(config =>
        {
            config.Address = new Uri("http://localhost:8500"); // Consul server address
        });
        
        var lifetime = host.Services.GetRequiredService<IHostApplicationLifetime>();
        var configuration = host.Services.GetRequiredService<IConfiguration>();
        
        var serviceId = $"{configuration["ServiceName"]}-{Guid.NewGuid()}";
        var serviceName = configuration["ServiceName"];
        var serviceAddress = configuration["ServiceAddress"];
        var servicePort = int.Parse(configuration["ServicePort"]);
        
        var registration = new AgentServiceRegistration
        {
            ID = serviceId,
            Name = serviceName,
            Address = serviceAddress,
            Port = servicePort,
            Check = new AgentServiceCheck
            {
                HTTP = $"http://{serviceAddress}:{servicePort}/health",
                Interval = TimeSpan.FromSeconds(10)
            }
        };
        
        consulClient.Agent.ServiceRegister(registration).Wait();
        
        lifetime.ApplicationStopping.Register(() =>
        {
            consulClient.Agent.ServiceDeregister(serviceId).Wait();
        });
        
        return host;
    }
}

// In Program.cs
var host = Host.CreateDefaultBuilder(args)
    .ConfigureWebHostDefaults(webBuilder =>
    {
        webBuilder.UseStartup<Startup>();
    })
    .Build()
    .UseConsul();

host.Run();

Discovering Services with Consul

csharp
public class ConsulServiceDiscovery
{
    private readonly ConsulClient _consulClient;
    private readonly Random _random = new Random();
    
    public ConsulServiceDiscovery()
    {
        _consulClient = new ConsulClient(config =>
        {
            config.Address = new Uri("http://localhost:8500");
        });
    }
    
    public async Task<Uri> GetServiceInstanceAsync(string serviceName)
    {
        var response = await _consulClient.Health.Service(serviceName, string.Empty, true);
        
        if (response?.Response?.Length == 0)
            throw new Exception($"No healthy instances of {serviceName} found.");
            
        // Choose a random instance for simple load balancing
        var instance = response.Response[_random.Next(response.Response.Length)];
        
        return new Uri($"http://{instance.Service.Address}:{instance.Service.Port}");
    }
}

// Usage
var serviceDiscovery = new ConsulServiceDiscovery();
var userServiceUrl = await serviceDiscovery.GetServiceInstanceAsync("user-service");

using var httpClient = new HttpClient();
var response = await httpClient.GetAsync($"{userServiceUrl}/api/users/1");

Using .NET Service Discovery with Steeltoe

Steeltoe is a great library that brings Spring-like capabilities to .NET, including service discovery.

First, install the required NuGet packages:

bash
dotnet add package Steeltoe.Discovery.ClientCore
dotnet add package Steeltoe.Discovery.Consul

Registering with Steeltoe and Consul

csharp
// In Program.cs
public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        })
        .AddServiceDiscovery(options => options.UseConsul());

// In Startup.cs
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Add discovery client
        services.AddDiscoveryClient(Configuration);
        
        // Other services...
    }
    
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // Activate discovery client
        app.UseDiscoveryClient();
        
        // Other middleware...
    }
}

In appsettings.json:

json
{
  "spring": {
    "application": {
      "name": "my-service"
    }
  },
  "consul": {
    "host": "localhost",
    "port": 8500,
    "discovery": {
      "register": true,
      "deregister": true,
      "preferIpAddress": true,
      "instanceId": "${spring:application:name}:${random.value}",
      "healthCheckPath": "/health"
    }
  }
}

Discovering Services with Steeltoe

csharp
public class ServiceController : ControllerBase
{
    private readonly DiscoveryHttpClientHandler _handler;
    private readonly ILogger<ServiceController> _logger;

    public ServiceController(IDiscoveryClient discoveryClient, ILogger<ServiceController> logger)
    {
        _handler = new DiscoveryHttpClientHandler(discoveryClient);
        _logger = logger;
    }

    [HttpGet]
    public async Task<IActionResult> Get()
    {
        try
        {
            using var client = new HttpClient(_handler, false);
            // "user-service" is the name of the service we want to call
            var response = await client.GetAsync("http://user-service/api/users");
            
            if (response.IsSuccessStatusCode)
            {
                var content = await response.Content.ReadAsStringAsync();
                return Ok(content);
            }
            
            return StatusCode((int)response.StatusCode);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error calling user service");
            return StatusCode(500);
        }
    }
}

DNS-based Service Discovery

.NET Core applications can also leverage DNS-based service discovery, which is particularly useful in Kubernetes environments.

csharp
public class DnsServiceDiscovery
{
    public async Task<string> CallServiceAsync()
    {
        using var httpClient = new HttpClient();
        
        // In Kubernetes, services can be discovered by their DNS name
        // For example, if you have a service named "user-service" in the same namespace
        var response = await httpClient.GetAsync("http://user-service/api/users");
        return await response.Content.ReadAsStringAsync();
    }
}

Real-World Example: Building a Resilient Microservice System

Let's put everything together in a more complete example:

csharp
public class OrderProcessingService
{
    private readonly IDiscoveryClient _discoveryClient;
    private readonly HttpClient _httpClient;
    private readonly ILogger<OrderProcessingService> _logger;
    
    public OrderProcessingService(
        IDiscoveryClient discoveryClient,
        HttpClient httpClient,
        ILogger<OrderProcessingService> logger)
    {
        _discoveryClient = discoveryClient;
        _httpClient = httpClient;
        _logger = logger;
    }
    
    public async Task<OrderResult> ProcessOrderAsync(OrderRequest orderRequest)
    {
        // 1. Validate inventory
        var inventoryServiceInstance = await GetServiceInstanceAsync("inventory-service");
        var inventoryResponse = await _httpClient.PostAsJsonAsync(
            $"{inventoryServiceInstance}/api/inventory/check", 
            new InventoryCheckRequest
            {
                ProductIds = orderRequest.Items.Select(i => i.ProductId).ToList(),
                Quantities = orderRequest.Items.Select(i => i.Quantity).ToList()
            });
        
        if (!inventoryResponse.IsSuccessStatusCode)
        {
            _logger.LogWarning("Inventory check failed for order");
            return new OrderResult { Success = false, Message = "Inventory check failed" };
        }
        
        // 2. Process payment
        var paymentServiceInstance = await GetServiceInstanceAsync("payment-service");
        var paymentResponse = await _httpClient.PostAsJsonAsync(
            $"{paymentServiceInstance}/api/payments", 
            new PaymentRequest
            {
                Amount = orderRequest.TotalAmount,
                PaymentMethod = orderRequest.PaymentMethod
            });
            
        if (!paymentResponse.IsSuccessStatusCode)
        {
            _logger.LogWarning("Payment processing failed for order");
            return new OrderResult { Success = false, Message = "Payment failed" };
        }
        
        // 3. Create shipping request
        var shippingServiceInstance = await GetServiceInstanceAsync("shipping-service");
        var shippingResponse = await _httpClient.PostAsJsonAsync(
            $"{shippingServiceInstance}/api/shipments",
            new ShippingRequest
            {
                OrderId = orderRequest.OrderId,
                Address = orderRequest.ShippingAddress
            });
            
        if (!shippingResponse.IsSuccessStatusCode)
        {
            _logger.LogWarning("Shipping request failed for order");
            return new OrderResult { Success = false, Message = "Shipping failed" };
        }
        
        return new OrderResult { Success = true, OrderId = orderRequest.OrderId };
    }
    
    private async Task<Uri> GetServiceInstanceAsync(string serviceName)
    {
        var instances = await _discoveryClient.GetInstancesAsync(serviceName);
        
        if (!instances.Any())
            throw new Exception($"No instances of {serviceName} available");
            
        // Simple round-robin selection
        var instance = instances.First();
        
        return new Uri($"{instance.Uri}");
    }
}

// These would be defined elsewhere
public class OrderRequest { /* Properties */ }
public class OrderResult { /* Properties */ }
public class InventoryCheckRequest { /* Properties */ }
public class PaymentRequest { /* Properties */ }
public class ShippingRequest { /* Properties */ }

Best Practices for Service Discovery in .NET

Health checks: Implement proper health checks so the discovery service can determine if your service is actually working.

csharp
// In Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddHealthChecks()
        .AddCheck("self", () => HealthCheckResult.Healthy())
        .AddDbContextCheck<ApplicationDbContext>("database");
}

public void Configure(IApplicationBuilder app)
{
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapHealthChecks("/health");
        endpoints.MapControllers();
    });
}

Circuit breaking: Combine service discovery with circuit breakers to handle failures gracefully.

csharp
// Using Polly for circuit breaking
services.AddHttpClient("inventory-service")
    .AddPolicyHandler(GetCircuitBreakerPolicy());

static IAsyncPolicy<HttpResponseMessage> GetCircuitBreakerPolicy()
{
    return HttpPolicyExtensions
        .HandleTransientHttpError()
        .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));
}

Cache discovery results: To avoid constant lookups, especially in high-traffic services.

csharp
public class CachedServiceDiscovery
{
    private readonly IDiscoveryClient _discoveryClient;
    private readonly IMemoryCache _cache;
    
    public CachedServiceDiscovery(IDiscoveryClient discoveryClient, IMemoryCache cache)
    {
        _discoveryClient = discoveryClient;
        _cache = cache;
    }
    
    public async Task<Uri> GetServiceInstanceAsync(string serviceName)
    {
        if (!_cache.TryGetValue($"service:{serviceName}", out Uri serviceUri))
        {
            var instances = await _discoveryClient.GetInstancesAsync(serviceName);
            if (!instances.Any())
                throw new Exception($"No instances of {serviceName} available");
                
            var instance = instances.First();
            serviceUri = new Uri($"{instance.Uri}");
            
            // Cache for 10 seconds
            _cache.Set($"service:{serviceName}", serviceUri, TimeSpan.FromSeconds(10));
        }
        
        return serviceUri;
    }
}

Summary

Service discovery is a fundamental pattern for building resilient, scalable distributed systems in .NET. In this guide, we covered:

The basic concepts of service discovery
Client-side vs server-side discovery patterns
Implementation using Consul with .NET
Using the Steeltoe framework for service discovery
DNS-based service discovery (particularly useful in Kubernetes)
A real-world example of service discovery in action
Best practices for implementing service discovery

By implementing service discovery in your .NET applications, you create systems that can dynamically adapt to changing environments, scale more easily, and recover gracefully from failures.

Additional Resources

Exercises

Set up a local Consul server and register a simple .NET API with it.
Create a client application that discovers and calls the registered service.
Implement health checks for your service that the discovery system can use.
Extend the example to use circuit breakers for resilience.
Simulate a service going down and observe how the system behaves with proper service discovery in place.

If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)

Introduction​

What is Service Discovery?​

Service Discovery Patterns in .NET​

Client-Side Discovery​

Server-Side Discovery​

Implementing Service Discovery in .NET​

Using Consul with .NET​

Registering a Service with Consul​

Discovering Services with Consul​

Using .NET Service Discovery with Steeltoe​

Registering with Steeltoe and Consul​

Discovering Services with Steeltoe​

DNS-based Service Discovery​

Real-World Example: Building a Resilient Microservice System​

Best Practices for Service Discovery in .NET​

Summary​

Additional Resources​

Exercises​