Microservices and Architecture

Eventual Consistency means that if no new updates are made to a data item, eventually all accesses to that item will return the last updated value. Unlike strong consistency, there may be a temporary period where different nodes have different versions of the data.

Key Concepts:

• Data updates propagate asynchronously across services
• Temporary inconsistencies are acceptable
• System favors availability over immediate consistency (CAP theorem)
• Eventually, all replicas converge to the same state

Example Scenario:

// Order Service - Creates order immediately
[HttpPost]
public async Task CreateOrder(CreateOrderRequest request)
{
    var order = new Order
    {
        CustomerId = request.CustomerId,
        Status = OrderStatus.Pending,
        Total = request.Total
    };
    
    await _orderRepository.AddAsync(order);
    
    // Publish event - asynchronous
    await _messageBus.PublishAsync(new OrderCreatedEvent
    {
        OrderId = order.Id,
        CustomerId = order.CustomerId,
        Items = request.Items
    });
    
    return Ok(order); // Returns immediately, other services update eventually
}

// Inventory Service - Updates stock eventually
public class OrderCreatedHandler : IEventHandler
{
    public async Task Handle(OrderCreatedEvent @event)
    {
        // This happens eventually, not immediately
        foreach (var item in @event.Items)
        {
            await _inventoryRepository.DecreaseStockAsync(item.ProductId, item.Quantity);
        }
    }
}

// Notification Service - Sends email eventually
public class OrderCreatedNotificationHandler : IEventHandler
{
    public async Task Handle(OrderCreatedEvent @event)
    {
        // This also happens eventually
        var customer = await _customerRepository.GetByIdAsync(@event.CustomerId);
        await _emailService.SendOrderConfirmationAsync(customer.Email, @event.OrderId);
    }
}

Handling Eventual Consistency:

// 1. Optimistic UI Updates
public class OrderViewModel
{
    public int OrderId { get; set; }
    public string Status { get; set; }
    public bool IsSyncing { get; set; } // Shows data is still being synchronized
}

// 2. Compensating Actions
public class OrderCompensationService
{
    public async Task CompensateFailedOrder(int orderId)
    {
        // If inventory update fails, compensate by canceling the order
        await _orderRepository.UpdateStatusAsync(orderId, OrderStatus.Cancelled);
        await _messageBus.PublishAsync(new OrderCancelledEvent { OrderId = orderId });
    }
}

// 3. Read Your Own Writes
public class OrderService
{
    private readonly IMemoryCache _cache;
    
    public async Task GetOrderAsync(int orderId, int userId)
    {
        // Check cache first for recently created orders
        if (_cache.TryGetValue($"order:{orderId}:{userId}", out Order cachedOrder))
        {
            return cachedOrder;
        }
        
        return await _orderRepository.GetByIdAsync(orderId);
    }
    
    public async Task CreateOrderAsync(CreateOrderRequest request)
    {
        var order = await _orderRepository.AddAsync(new Order { /* ... */ });
        
        // Cache for immediate read
        _cache.Set($"order:{order.Id}:{request.UserId}", order, TimeSpan.FromMinutes(5));
        
        return order;
    }
}

// 4. Version Vectors/Timestamps
public class EventEnvelope
{
    public T Event { get; set; }
    public long Timestamp { get; set; }
    public string EventId { get; set; }
    public int Version { get; set; }
}

public class EventProcessor
{
    private long _lastProcessedTimestamp;
    
    public async Task ProcessEvent(EventEnvelope envelope)
    {
        // Ignore out-of-order events
        if (envelope.Timestamp <= _lastProcessedTimestamp)
        {
            return;
        }
        
        await HandleEvent(envelope.Event);
        _lastProcessedTimestamp = envelope.Timestamp;
    }
}

The Saga pattern manages data consistency across microservices in distributed transactions by breaking the transaction into a series of local transactions, each with a compensating transaction to undo changes if something fails.

Two Types:

1. Choreography-based Saga (Event-driven):

// Order Service
public class OrderService
{
    public async Task CreateOrder(CreateOrderRequest request)
    {
        var order = new Order { Status = OrderStatus.Pending };
        await _repository.AddAsync(order);
        
        // Publish event to start saga
        await _eventBus.PublishAsync(new OrderCreatedEvent
        {
            OrderId = order.Id,
            CustomerId = request.CustomerId,
            Items = request.Items,
            Total = request.Total
        });
        
        return order;
    }
    
    // Compensating transaction
    public async Task CancelOrder(OrderCancelledEvent @event)
    {
        await _repository.UpdateStatusAsync(@event.OrderId, OrderStatus.Cancelled);
    }
}

// Inventory Service
public class InventoryEventHandler
{
    public async Task Handle(OrderCreatedEvent @event)
    {
        try
        {
            // Reserve inventory
            await _inventoryService.ReserveItemsAsync(@event.Items);
            
            // Publish success event
            await _eventBus.PublishAsync(new InventoryReservedEvent
            {
                OrderId = @event.OrderId,
                Items = @event.Items
            });
        }
        catch (InsufficientStockException)
        {
            // Publish failure event
            await _eventBus.PublishAsync(new InventoryReservationFailedEvent
            {
                OrderId = @event.OrderId
            });
        }
    }
    
    // Compensating transaction
    public async Task Handle(OrderCancelledEvent @event)
    {
        await _inventoryService.ReleaseReservationAsync(@event.OrderId);
    }
}

// Payment Service
public class PaymentEventHandler
{
    public async Task Handle(InventoryReservedEvent @event)
    {
        try
        {
            await _paymentService.ProcessPaymentAsync(@event.OrderId);
            
            await _eventBus.PublishAsync(new PaymentProcessedEvent
            {
                OrderId = @event.OrderId
            });
        }
        catch (PaymentFailedException)
        {
            // Trigger compensation
            await _eventBus.PublishAsync(new PaymentFailedEvent
            {
                OrderId = @event.OrderId
            });
        }
    }
    
    // Compensating transaction
    public async Task Handle(OrderCancelledEvent @event)
    {
        await _paymentService.RefundAsync(@event.OrderId);
    }
}

2. Orchestration-based Saga (Centralized coordinator):

// Saga Orchestrator
public class OrderSagaOrchestrator
{
    private readonly IOrderService _orderService;
    private readonly IInventoryService _inventoryService;
    private readonly IPaymentService _paymentService;
    
    public async Task ExecuteOrderSaga(CreateOrderRequest request)
    {
        var sagaState = new SagaState();
        
        try
        {
            // Step 1: Create Order
            var order = await _orderService.CreateOrderAsync(request);
            sagaState.OrderId = order.Id;
            sagaState.CompletedSteps.Add(SagaStep.OrderCreated);
            
            // Step 2: Reserve Inventory
            await _inventoryService.ReserveItemsAsync(order.Id, request.Items);
            sagaState.CompletedSteps.Add(SagaStep.InventoryReserved);
            
            // Step 3: Process Payment
            await _paymentService.ProcessPaymentAsync(order.Id, request.Total);
            sagaState.CompletedSteps.Add(SagaStep.PaymentProcessed);
            
            // Step 4: Confirm Order
            await _orderService.ConfirmOrderAsync(order.Id);
            
            return SagaResult.Success(order.Id);
        }
        catch (Exception ex)
        {
            // Compensate in reverse order
            await CompensateAsync(sagaState);
            return SagaResult.Failure(ex.Message);
        }
    }
    
    private async Task CompensateAsync(SagaState state)
    {
        if (state.CompletedSteps.Contains(SagaStep.PaymentProcessed))
        {
            await _paymentService.RefundAsync(state.OrderId);
        }
        
        if (state.CompletedSteps.Contains(SagaStep.InventoryReserved))
        {
            await _inventoryService.ReleaseReservationAsync(state.OrderId);
        }
        
        if (state.CompletedSteps.Contains(SagaStep.OrderCreated))
        {
            await _orderService.CancelOrderAsync(state.OrderId);
        }
    }
}

// Saga State Management
public class SagaState
{
    public int OrderId { get; set; }
    public List CompletedSteps { get; set; } = new();
}

public enum SagaStep
{
    OrderCreated,
    InventoryReserved,
    PaymentProcessed
}

// Using MassTransit for Saga Orchestration
public class OrderStateMachine : MassTransitStateMachine
{
    public OrderStateMachine()
    {
        InstanceState(x => x.CurrentState);
        
        Event(() => OrderCreated);
        Event(() => InventoryReserved);
        Event(() => PaymentProcessed);
        
        Initially(
            When(OrderCreated)
                .Then(context => context.Instance.OrderId = context.Data.OrderId)
                .TransitionTo(AwaitingInventory)
                .Publish(context => new ReserveInventoryCommand(context.Data.OrderId)));
        
        During(AwaitingInventory,
            When(InventoryReserved)
                .TransitionTo(AwaitingPayment)
                .Publish(context => new ProcessPaymentCommand(context.Data.OrderId)));
        
        During(AwaitingPayment,
            When(PaymentProcessed)
                .TransitionTo(Completed)
                .Publish(context => new OrderCompletedEvent(context.Data.OrderId)));
    }
    
    public State AwaitingInventory { get; private set; }
    public State AwaitingPayment { get; private set; }
    public State Completed { get; private set; }
    
    public Event OrderCreated { get; private set; }
    public Event InventoryReserved { get; private set; }
    public Event PaymentProcessed { get; private set; }
}

Service Discovery allows services to find and communicate with each other without hard-coding network locations. Services register themselves and discover other services dynamically.

1. Client-Side Discovery with Consul:

// Install: Install-Package Consul

// Service Registration
public class ConsulServiceRegistration : IHostedService
{
    private readonly IConsulClient _consulClient;
    private readonly IConfiguration _configuration;
    private string _registrationId;
    
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        var serviceName = _configuration["ServiceName"];
        var serviceId = $"{serviceName}-{Guid.NewGuid()}";
        
        var registration = new AgentServiceRegistration
        {
            ID = serviceId,
            Name = serviceName,
            Address = _configuration["ServiceAddress"],
            Port = int.Parse(_configuration["ServicePort"]),
            Check = new AgentServiceCheck
            {
                HTTP = $"http://{_configuration["ServiceAddress"]}:{_configuration["ServicePort"]}/health",
                Interval = TimeSpan.FromSeconds(10),
                Timeout = TimeSpan.FromSeconds(5)
            }
        };
        
        await _consulClient.Agent.ServiceDeregister(serviceId, cancellationToken);
        await _consulClient.Agent.ServiceRegister(registration, cancellationToken);
        
        _registrationId = serviceId;
    }
    
    public async Task StopAsync(CancellationToken cancellationToken)
    {
        await _consulClient.Agent.ServiceDeregister(_registrationId, cancellationToken);
    }
}

// Service Discovery
public class ConsulServiceDiscovery
{
    private readonly IConsulClient _consulClient;
    
    public async Task GetServiceUriAsync(string serviceName)
    {
        var services = await _consulClient.Health.Service(serviceName, tag: null, passingOnly: true);
        
        if (!services.Response.Any())
        {
            throw new Exception($"Service {serviceName} not found");
        }
        
        // Simple round-robin
        var service = services.Response[Random.Shared.Next(services.Response.Length)];
        
        return new Uri($"http://{service.Service.Address}:{service.Service.Port}");
    }
}

// Usage in HttpClient
public class OrderServiceClient
{
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly ConsulServiceDiscovery _serviceDiscovery;
    
    public async Task GetOrderAsync(int orderId)
    {
        var serviceUri = await _serviceDiscovery.GetServiceUriAsync("order-service");
        var client = _httpClientFactory.CreateClient();
        client.BaseAddress = serviceUri;
        
        return await client.GetFromJsonAsync($"/api/orders/{orderId}");
    }
}

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton(p => new ConsulClient(config =>
    {
        config.Address = new Uri("http://consul:8500");
    }));
    
    services.AddSingleton();
    services.AddHostedService();
}

2. Server-Side Discovery with Kubernetes:

# Kubernetes Service Definition
apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  selector:
    app: order-service
  ports:
    - protocol: TCP
      port: 80
      targetPort: 5000
  type: ClusterIP

// In .NET Core, services discover each other via Kubernetes DNS
public void ConfigureServices(IServiceCollection services)
{
    services.AddHttpClient("OrderService", c =>
    {
        // Kubernetes DNS: ..svc.cluster.local
        c.BaseAddress = new Uri("http://order-service.default.svc.cluster.local");
    });
}

3. Using Eureka (Netflix OSS):

// Install: Install-Package Steeltoe.Discovery.Eureka

// appsettings.json
{
  "spring": {
    "application": {
      "name": "product-service"
    }
  },
  "eureka": {
    "client": {
      "serviceUrl": "http://eureka-server:8761/eureka/",
      "shouldRegisterWithEureka": true,
      "shouldFetchRegistry": true
    },
    "instance": {
      "port": 5000,
      "preferIpAddress": true,
      "healthCheckUrlPath": "/health"
    }
  }
}

// Program.cs
public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);
        
        builder.Services.AddDiscoveryClient(builder.Configuration);
        builder.Services.AddHttpClient();
        
        var app = builder.Build();
        app.Run();
    }
}

// Service Client with Discovery
public class ProductServiceClient
{
    private readonly IDiscoveryClient _discoveryClient;
    private readonly IHttpClientFactory _httpClientFactory;
    
    public ProductServiceClient(IDiscoveryClient discoveryClient, IHttpClientFactory httpClientFactory)
    {
        _discoveryClient = discoveryClient;
        _httpClientFactory = httpClientFactory;
    }
    
    public async Task GetProductAsync(int productId)
    {
        var instances = await _discoveryClient.GetInstancesAsync("product-service");
        var instance = instances.FirstOrDefault();
        
        if (instance == null)
            throw new Exception("No instances of product-service available");
        
        var client = _httpClientFactory.CreateClient();
        var uri = new Uri($"{instance.Uri}/api/products/{productId}");
        
        return await client.GetFromJsonAsync(uri);
    }
}

4. Custom Service Registry:

// Simple in-memory service registry
public interface IServiceRegistry
{
    Task RegisterServiceAsync(ServiceRegistration registration);
    Task DeregisterServiceAsync(string serviceId);
    Task<List> DiscoverServiceAsync(string serviceName);
}

public class InMemoryServiceRegistry : IServiceRegistry
{
    private readonly ConcurrentDictionary _services = new();
    
    public Task RegisterServiceAsync(ServiceRegistration registration)
    {
        _services[registration.ServiceId] = registration;
        return Task.CompletedTask;
    }
    
    public Task DeregisterServiceAsync(string serviceId)
    {
        _services.TryRemove(serviceId, out _);
        return Task.CompletedTask;
    }
    
    public Task<List> DiscoverServiceAsync(string serviceName)
    {
        var instances = _services.Values
            .Where(s => s.ServiceName == serviceName && s.IsHealthy)
            .Select(s => new ServiceInstance
            {
                ServiceId = s.ServiceId,
                Host = s.Host,
                Port = s.Port
            })
            .ToList();
        
        return Task.FromResult(instances);
    }
}

public class ServiceRegistration
{
    public string ServiceId { get; set; }
    public string ServiceName { get; set; }
    public string Host { get; set; }
    public int Port { get; set; }
    public bool IsHealthy { get; set; }
    public DateTime LastHeartbeat { get; set; }
}

Containers are lightweight, standalone packages that include application code, runtime, libraries, and dependencies needed to run the application. They provide isolation and consistency across different environments.

Why Containers for Microservices:

• Isolation: Each microservice runs in its own container
• Portability: Run anywhere (dev, test, production)
• Scalability: Easy to scale individual services
• Consistency: Same environment across all stages
• Resource Efficiency: Lighter than virtual machines
• Fast Deployment: Quick startup and shutdown

Docker for .NET Core:

1. Dockerfile for .NET Core Service:

# Build stage
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src

# Copy csproj and restore dependencies
COPY ["ProductService/ProductService.csproj", "ProductService/"]
RUN dotnet restore "ProductService/ProductService.csproj"

# Copy source code and build
COPY . .
WORKDIR "/src/ProductService"
RUN dotnet build "ProductService.csproj" -c Release -o /app/build

# Publish stage
FROM build AS publish
RUN dotnet publish "ProductService.csproj" -c Release -o /app/publish

# Runtime stage
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
WORKDIR /app
COPY --from=publish /app/publish .

# Configure environment
ENV ASPNETCORE_URLS=http://+:80
EXPOSE 80

ENTRYPOINT ["dotnet", "ProductService.dll"]

2. Docker Compose for Multiple Services:

# docker-compose.yml
version: '3.8'

services:
  # API Gateway
  api-gateway:
    build:
      context: ./ApiGateway
      dockerfile: Dockerfile
    ports:
      - "5000:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
    depends_on:
      - product-service
      - order-service
    networks:
      - microservices-network

  # Product Service
  product-service:
    build:
      context: ./ProductService
      dockerfile: Dockerfile
    ports:
      - "5001:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
      - ConnectionStrings__DefaultConnection=Server=product-db;Database=Products;User=sa;Password=YourPassword123
    depends_on:
      - product-db
    networks:
      - microservices-network

  # Order Service
  order-service:
    build:
      context: ./OrderService
      dockerfile: Dockerfile
    ports:
      - "5002:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
      - ConnectionStrings__DefaultConnection=Server=order-db;Database=Orders;User=sa;Password=YourPassword123
      - RabbitMQ__Host=rabbitmq
    depends_on:
      - order-db
      - rabbitmq
    networks:
      - microservices-network

  # Databases
  product-db:
    image: mcr.microsoft.com/mssql/server:2022-latest
    environment:
      - ACCEPT_EULA=Y
      - SA_PASSWORD=YourPassword123
    ports:
      - "1433:1433"
    volumes:
      - product-data:/var/opt/mssql
    networks:
      - microservices-network

  order-db:
    image: mcr.microsoft.com/mssql/server:2022-latest
    environment:
      - ACCEPT_EULA=Y
      - SA_PASSWORD=YourPassword123
    ports:
      - "1434:1433"
    volumes:
      - order-data:/var/opt/mssql
    networks:
      - microservices-network

  # Message Broker
  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "5672:5672"
      - "15672:15672"
    environment:
      - RABBITMQ_DEFAULT_USER=guest
      - RABBITMQ_DEFAULT_PASS=guest
    networks:
      - microservices-network

  # Redis Cache
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"
    networks:
      - microservices-network

networks:
  microservices-network:
    driver: bridge

volumes:
  product-data:
  order-data:

3. Running Docker Commands:

# Build and run all services
docker-compose up -d

# Build specific service
docker-compose build product-service

# View logs
docker-compose logs -f product-service

# Scale a service
docker-compose up -d --scale order-service=3

# Stop all services
docker-compose down

# Remove volumes
docker-compose down -v

4. .NET Core Container Configuration:

// Program.cs - Container-aware configuration
public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);
        
        // Configure Kestrel for container
        builder.WebHost.ConfigureKestrel(options =>
        {
            options.ListenAnyIP(80); // Listen on all interfaces
        });
        
        // Add health checks for container orchestration
        builder.Services.AddHealthChecks()
            .AddSqlServer(builder.Configuration.GetConnectionString("DefaultConnection"))
            .AddRabbitMQ(builder.Configuration["RabbitMQ:Host"]);
        
        var app = builder.Build();
        
        // Health check endpoint for container health probes
        app.MapHealthChecks("/health");
        app.MapHealthChecks("/ready", new HealthCheckOptions
        {
            Predicate = check => check.Tags.Contains("ready")
        });
        
        app.Run();
    }
}

5. Kubernetes Deployment:

# product-service-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: product-service
  template:
    metadata:
      labels:
        app: product-service
    spec:
      containers:
      - name: product-service
        image: myregistry/product-service:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_ENVIRONMENT
          value: "Production"
        - name: ConnectionStrings__DefaultConnection
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: connection-string
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: product-service
spec:
  selector:
    app: product-service
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP

The Strangler Pattern (named after strangler fig trees that grow around existing trees) is an incremental approach to migrating from a monolithic application to microservices by gradually replacing specific pieces of functionality with new services.

Migration Strategy:

Phase 1: Setup Strangler Facade

// API Gateway/Proxy that routes to monolith or microservices
public class StranglerFacadeMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IConfiguration _configuration;
    
    public async Task InvokeAsync(HttpContext context)
    {
        var path = context.Request.Path.Value;
        
        // Route new functionality to microservices
        if (path.StartsWith("/api/products"))
        {
            await ProxyToMicroservice(context, "ProductService");
        }
        else if (path.StartsWith("/api/orders"))
        {
            await ProxyToMicroservice(context, "OrderService");
        }
        else
        {
            // Route everything else to legacy monolith
            await ProxyToMonolith(context);
        }
    }
    
    private async Task ProxyToMicroservice(HttpContext context, string serviceName)
    {
        var serviceUrl = _configuration[$"Services:{serviceName}:Url"];
        // Forward request to microservice
        await ForwardRequest(context, serviceUrl);
    }
    
    private async Task ProxyToMonolith(HttpContext context)
    {
        var monolithUrl = _configuration["Monolith:Url"];
        await ForwardRequest(context, monolithUrl);
    }
}

Phase 2: Extract First Service

// Original Monolith - Product Module
public class MonolithProductController : ControllerBase
{
    private readonly MonolithDbContext _dbContext;
    
    [HttpGet("api/products/{id}")]
    public async Task GetProduct(int id)
    {
        var product = await _dbContext.Products
            .Include(p => p.Category)
            .Include(p => p.Inventory)
            .FirstOrDefaultAsync(p => p.Id == id);
        
        return Ok(product);
    }
}

// Step 1: Create new Product Microservice
public class ProductMicroserviceController : ControllerBase
{
    private readonly IProductRepository _repository;
    
    [HttpGet("api/products/{id}")]
    public async Task GetProduct(int id)
    {
        var product = await _repository.GetByIdAsync(id);
        return Ok(product);
    }
}

// Step 2: Synchronize data between monolith and microservice during transition
public class ProductDataSyncService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            // Sync from monolith to microservice
            var products = await _monolithRepository.GetRecentlyUpdatedAsync();
            
            foreach (var product in products)
            {
                await _microserviceRepository.UpsertAsync(product);
            }
            
            await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
        }
    }
}

Phase 3: Implement Anti-Corruption Layer

// Anti-corruption layer to translate between monolith and microservice models
public class ProductAdapter
{
    // Convert monolith model to microservice model
    public ProductDto ToMicroserviceModel(MonolithProduct monolithProduct)
    {
        return new ProductDto
        {
            Id = monolithProduct.ProductId,
            Name = monolithProduct.ProductName,
            Price = monolithProduct.UnitPrice,
            SKU = monolithProduct.StockKeepingUnit,
            Category = new CategoryDto
            {
                Id = monolithProduct.CategoryId,
                Name = monolithProduct.CategoryName
            }
        };
    }
    
    // Convert microservice model back to monolith format if needed
    public MonolithProduct ToMonolithModel(ProductDto microserviceProduct)
    {
        return new MonolithProduct
        {
            ProductId = microserviceProduct.Id,
            ProductName = microserviceProduct.Name,
            UnitPrice = microserviceProduct.Price,
            StockKeepingUnit = microserviceProduct.SKU,
            CategoryId = microserviceProduct.Category.Id
        };
    }
}

// Service that uses both systems during migration
public class HybridProductService
{
    private readonly MonolithProductService _monolithService;
    private readonly ProductMicroserviceClient _microserviceClient;
    private readonly IFeatureManager _featureManager;
    
    public async Task GetProductAsync(int productId)
    {
        // Feature flag to gradually shift traffic
        if (await _featureManager.IsEnabledAsync("UseProductMicroservice"))
        {
            return await _microserviceClient.GetProductAsync(productId);
        }
        else
        {
            var monolithProduct = await _monolithService.GetProductAsync(productId);
            return _adapter.ToMicroserviceModel(monolithProduct);
        }
    }
}

Phase 4: Gradual Migration with Feature Flags

// appsettings.json
{
  "FeatureManagement": {
    "UseProductMicroservice": {
      "EnabledFor": [
        {
          "Name": "Percentage",
          "Parameters": {
            "Value": 10  // Start with 10% of traffic
          }
        }
      ]
    }
  }
}

// Program.cs
builder.Services.AddFeatureManagement();

// Gradually increase percentage: 10% → 25% → 50% → 75% → 100%
public class GradualMigrationService
{
    private readonly IFeatureManager _featureManager;
    
    public async Task ExecuteWithFallback(
        Func<Task> microserviceAction,
        Func<Task> monolithAction)
    {
        if (await _featureManager.IsEnabledAsync("UseProductMicroservice"))
        {
            try
            {
                return await microserviceAction();
            }
            catch (Exception ex)
            {
                // Fallback to monolith if microservice fails
                _logger.LogWarning(ex, "Microservice failed, falling back to monolith");
                return await monolithAction();
            }
        }
        
        return await monolithAction();
    }
}

Phase 5: Database Migration

// Step 1: Read from monolith, write to both
public class DualWriteProductRepository : IProductRepository
{
    private readonly MonolithDbContext _monolithDb;
    private readonly MicroserviceDbContext _microserviceDb;
    
    public async Task AddAsync(Product product)
    {
        // Write to monolith first (existing system)
        await _monolithDb.Products.AddAsync(product);
        await _monolithDb.SaveChangesAsync();
        
        // Also write to microservice database
        try
        {
            await _microserviceDb.Products.AddAsync(product);
            await _microserviceDb.SaveChangesAsync();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to write to microservice DB");
            // Don't fail - monolith is still source of truth
        }
        
        return product;
    }
}

// Step 2: Backfill historical data
public class DataMigrationService
{
    public async Task MigrateProductsAsync()
    {
        var batchSize = 1000;
        var offset = 0;
        
        while (true)
        {
            var products = await _monolithDb.Products
                .Skip(offset)
                .Take(batchSize)
                .ToListAsync();
            
            if (!products.Any())
                break;
            
            await _microserviceDb.Products.AddRangeAsync(products);
            await _microserviceDb.SaveChangesAsync();
            
            offset += batchSize;
            _logger.LogInformation($"Migrated {offset} products");
        }
    }
}

// Step 3: Switch reads to microservice, continue dual writes
// Step 4: Stop writing to monolith, read/write only to microservice
// Step 5: Decommission monolith database access

Phase 6: Complete Migration and Cleanup

// Remove strangler facade routing
public class Startup
{
    public void Configure(IApplicationBuilder app)
    {
        // Remove: app.UseMiddleware();
        
        // Direct routing to microservices only
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

// Decommission monolith code
// Remove MonolithProductService, MonolithDbContext, etc.
// Update all references to use microservice clients directly

public class ProductService
{
    private readonly ProductMicroserviceClient _client;
    
    // No more reference to monolith
    public async Task GetProductAsync(int id)
    {
        return await _client.GetProductAsync(id);
    }
}

Migration Checklist:

1. ✅ Set up API Gateway/Strangler Facade
2. ✅ Identify bounded context to extract
3. ✅ Create new microservice
4. ✅ Implement anti-corruption layer
5. ✅ Set up dual-write for data
6. ✅ Migrate historical data
7. ✅ Use feature flags for gradual rollout
8. ✅ Monitor both systems
9. ✅ Switch reads to microservice
10. ✅ Stop writes to monolith
11. ✅ Decommission monolith components
12. ✅ Remove strangler facade

Best Practices:

• Start with least dependent modules
• Use feature flags for safe rollback
• Maintain backward compatibility
• Monitor performance closely
• Have rollback plan ready
• Communicate with stakeholders
• Document the migration process

---

Summary

This guide covered essential microservices concepts in .NET Core:

• Architecture: Understanding microservices vs monolithic approaches
• Communication: Synchronous (HTTP, gRPC) and asynchronous (message queues)
• Patterns: API Gateway, Circuit Breaker, Saga, Strangler
• Infrastructure: Service discovery, containers, orchestration
• Data: Eventual consistency, distributed transactions

Key Takeaways:

• Microservices add complexity but provide scalability and flexibility
• Choose the right patterns for your use case
• Invest in proper infrastructure (containers, orchestration, monitoring)
• Migrate incrementally using patterns like Strangler
• Plan for failure with Circuit Breaker and resilience patterns

Recommended Tools for .NET Core:

• API Gateway: Ocelot, YARP
• Service Discovery: Consul, Eureka, Kubernetes
• Messaging: RabbitMQ, Azure Service Bus, Kafka
• Resilience: Polly
• Containers: Docker, Kubernetes
• Monitoring: Application Insights, Prometheus, Grafana