.Net Core Micro Servis ve Servis Discovery Örneği

public class ServiceConfigDto
{
    public Uri ServiceDiscoveryAddress { get; set; }
    public Uri ServiceAddress { get; set; }
    public string ServiceName { get; set; }
    public string ServiceId { get; set; }

    public int TcpCheckTimeOutAsMin { get; set; }
    public int TcpCheckIntervalAsSec { get; set; }
    public int HealtCheckTimeOutAsMin { get; set; }
    public int HealtCheckIntervalAsSec { get; set; }
}

public class ServiceDiscoveryHostedService : IHostedService
    {
        private readonly IConsulClient _client;
        private readonly ServiceConfigDto _config;
        private string _registrationId;

        public ServiceDiscoveryHostedService(
            IConsulClient client,
            ServiceConfigDto serviceConfig
            )
        {
            _client = client;
            _config = serviceConfig;
        }

    	///bu kısım servis ayağa kalktığında çalışır.
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            ///her servis için uniq bir registrationId oluşturuyoruz.
            _registrationId = $"{_config.ServiceName}-{_config.ServiceId}";
		///consule gönderilecek registration bilgisini oluşturuyoruz.
            var registration = new AgentServiceRegistration
            {
                ID = _registrationId, //servis reg Id
                Name = _config.ServiceName, //servis adı
                Address = _config.ServiceAddress.Host, //servis adresi
                Port = _config.ServiceAddress.Port, //servis portu
                Checks = new AgentServiceCheck[] //servisin nasıl kontrol edilmesini istersek.
                {
                    //servisi Interval aralıkla kontrol et. DeregisterCriticalServiceAfter kadar süre içinde yanıt gelmez ise servis kapalı kabul et. TCP üzerinden kontrol et.
                    new AgentServiceCheck
                    {
                        DeregisterCriticalServiceAfter = TimeSpan.FromMinutes(_config.TcpCheckTimeOutAsMin),
                        Interval = TimeSpan.FromSeconds(_config.TcpCheckIntervalAsSec),
                        TCP = $"{_config.ServiceAddress.Host}:{_config.ServiceAddress.Port}"
                    },
                    //servisi Interval aralıkla kontrol et. DeregisterCriticalServiceAfter kadar süre içinde yanıt gelmez ise servis kapalı kabul et. HTTP üzerinden kontrol et.
                    new AgentServiceCheck
                    {
                        DeregisterCriticalServiceAfter = TimeSpan.FromMinutes(_config.HealtCheckTimeOutAsMin),
                        Interval = TimeSpan.FromSeconds(_config.HealtCheckIntervalAsSec),
                        HTTP = $"{_config.ServiceAddress.Scheme}://{_config.ServiceAddress.Host}:{_config.ServiceAddress.Port}/HealthCheck"
                    }
                }
            };
			///daha önce bu reg id ile kayıtlı servisin kaydını varsa sil.
            await _client.Agent.ServiceDeregister(registration.ID, cancellationToken);
            ///yeni servisi kaydet.
            await _client.Agent.ServiceRegister(registration, cancellationToken);
        }
		///bu kısım servis durdurulduğunda çalışır.
        public async Task StopAsync(CancellationToken cancellationToken)
        {
            ///consule servis kapandı bilgisini iletir.
            await _client.Agent.ServiceDeregister(_registrationId, cancellationToken);
        }
    }

using Consul;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;

namespace SampleMicroService.Infrastructure
{
    public static class StartUpExtentions
    {
        public static ServiceConfigDto GetServiceConfig(
            this IConfiguration configuration
            )
        {
            return new ServiceConfigDto
            {
                ServiceDiscoveryAddress = configuration.GetValue<Uri>("ServiceConfig:serviceDiscoveryAddress"),
                ServiceAddress = configuration.GetValue<Uri>("ServiceConfig:serviceAddress"),
                ServiceName = configuration.GetValue<string>("ServiceConfig:serviceName"),
                ServiceId = configuration.GetValue<string>("ServiceConfig:serviceId"),
                TcpCheckTimeOutAsMin = configuration.GetValue<int>("ServiceConfig:tcpCheckTimeOutAsMin"),
                TcpCheckIntervalAsSec = configuration.GetValue<int>("ServiceConfig:tcpCheckIntervalAsSec"),
                HealtCheckTimeOutAsMin = configuration.GetValue<int>("ServiceConfig:healtCheckTimeOutAsMin"),
                HealtCheckIntervalAsSec = configuration.GetValue<int>("ServiceConfig:healtCheckIntervalAsSec")
            };
        }

        public static void RegisterConsulServices(
            this IServiceCollection services,
            ServiceConfigDto serviceConfig
            )
        {
            var consulClient = new ConsulClient(config =>
            {
                config.Address = serviceConfig.ServiceDiscoveryAddress;
            }
             );

            services.AddSingleton(serviceConfig);
            services.AddSingleton<IConsulClient, ConsulClient>(p => consulClient);
            services.AddSingleton<IHostedService, ServiceDiscoveryHostedService>();
        }
    }
}

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

namespace SampleMicroService.OrderService.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class DemoController : ControllerBase
    {
        private readonly IHttpContextAccessor _httpContextAccessor;
        public DemoController(
            IHttpContextAccessor httpContextAccessor
            )
        {
            _httpContextAccessor = httpContextAccessor;
        }

        /// <summary>
        /// Demo değerleri döner
        /// </summary>
        /// <returns>Dizi döner</returns>
        [HttpGet]
        [Route("List")]
        public async Task<IActionResult> GetList()
        {
            return Ok(new string[] { "item1", "item2", "item3" });
        }

        /// <summary>
        /// Tek bir demo değeri döner
        /// </summary>
        /// <param name="id">demo değer id</param>
        /// <returns>demo değeri</returns>
        [HttpGet]
        [Route("Single/{id}")]
        public async Task<IActionResult> GetSingle(int id)
        {
            return Ok("item" + id);
        }
    }
}

using Microsoft.AspNetCore.Mvc;

namespace SampleMicroService.OrderService.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class HealthCheckController : ControllerBase
    {
        [HttpGet("")]
        [HttpHead("")]
        public IActionResult Ping()
        {
            return Ok();
        }
    }
}

public class Startup
    {
        /// <summary>
        /// Configuration'ı inject alıyoruz.
        /// </summary>
        public IConfiguration Configuration { get; }
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //Configuration içindeki değerleri alıyoruz.
            var serviceConfig = Configuration.GetServiceConfig();
            //Servisin consul'e kayıt olması için ayarlamaları uyguluyoruz.
            services.RegisterConsulServices(serviceConfig);

            services.AddControllers();
            services.AddHttpContextAccessor();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
                endpoints.MapGet("/version", async context =>
                {
                    await context.Response.WriteAsync($"v{Assembly.GetExecutingAssembly().GetName().Version}");
                });
            });
        }
    }

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Ocelot.DependencyInjection;
using Ocelot.Middleware;
using Ocelot.Provider.Consul;
using System.IO;

namespace SampleMicroService.GateWay
{
    public class Program
    {
        public static void Main(string[] args)
        {
            new WebHostBuilder()
                .UseKestrel()
                .UseContentRoot(Directory.GetCurrentDirectory())
                .ConfigureAppConfiguration((context, config) =>
                {
                    config
                        .SetBasePath(context.HostingEnvironment.ContentRootPath)
                        .AddJsonFile("appsettings.json", true, true)
                        .AddJsonFile(
                            $"appsettings.{context.HostingEnvironment.EnvironmentName}.json",
                            true,
                            true
                        )
                        .AddJsonFile("ocelot.json")
                        .AddEnvironmentVariables();
                })
                .ConfigureServices((context, services) =>
                {
                    //AddConsul.
                    services.AddOcelot().AddConsul();
                })
                .ConfigureLogging((hostingContext, logging) =>
                {
                    logging.AddConsole();
                })
                .Configure(app =>
                {
                    app.UseOcelot().Wait();
                })
                .Build()
                .Run();
        }
    }
}