.NET Microservices on Azure: Enterprise Architecture Guide for C# Developers (Complete 2026)

❌ Deploy ASP.NET Core to single Azure App Service
❌ Tight coupling between application and infrastructure
❌ Hard to scale individual services
❌ Difficult to handle failures gracefully
❌ Monitoring is application-level only (no infrastructure visibility)
❌ Can't update one service without impacting others

❌ Deploy each service to Kubernetes
✅ Great scalability
❌ BUT: Doesn't leverage C# async patterns
❌ Overkill for some .NET workloads
❌ Added complexity with .NET's lightweight footprint
❌ Cost balloons (you're paying for Kubernetes overhead)

✅ Each microservice is independently deployable
✅ Leverages C# async/await for efficient resource usage
✅ Auto-scaling based on actual metrics (not guessing)
✅ Failures isolated (one service down ≠ entire system down)
✅ Infrastructure + Application monitoring combined
✅ Update services independently, zero downtime
✅ Cost-optimized (pay for what you use)
✅ Development to production: Same deployment pattern

Developer pushes code to GitHub
    ↓
GitHub Actions triggers CI/CD
    ├─ Build: Compile C# projects
    ├─ Test: Run unit tests
    ├─ Build Images: Create Docker images (optimized for .NET)
    └─ Push: Send to Azure Container Registry
    ↓
Kubernetes in Azure (AKS) receives signal
    ├─ Pull latest images
    ├─ Start new pods (with health checks)
    ├─ Stop old pods gracefully
    └─ Route traffic to new pods (zero downtime)
    ↓
Running Microservices
    ├─ UserService (authentication)
    ├─ ProductService (business logic)
    ├─ OrderService (order processing)
    └─ NotificationService (email/SMS)
    ↓
All services monitored
    ├─ Application Insights (C# code-level monitoring)
    ├─ Prometheus (infrastructure metrics)
    ├─ Loki (centralized logging)
    └─ Grafana (unified dashboards)
    ↓
When something breaks:
    ├─ Alert fires
    ├─ You know EXACTLY what failed (code + infra)
    ├─ Logs tell story from code → container → infrastructure
    └─ Rollback: One command, instant recovery

❌ One "MonolithService" 
❌ One database shared by everything
❌ Everything in same codebase
Result: Can't scale, can't deploy independently, one bug = everything fails

UserService: Authentication, user management
├─ Database: PostgreSQL (users only)
├─ Responsibility: Single - manage user identity
├─ Scale: Independent

ProductService: Product catalog, inventory
├─ Database: PostgreSQL (products only)
├─ Responsibility: Single - manage products
├─ Scale: Independent

OrderService: Order processing, business logic
├─ Database: PostgreSQL (orders only)
├─ Dependency: Calls UserService + ProductService
├─ Responsibility: Single - manage orders
├─ Scale: Independent

NotificationService: Email, SMS, notifications
├─ Database: None (or cache only)
├─ Dependency: Listens to events from other services
├─ Responsibility: Single - send notifications
├─ Scale: Independent (handles spikes independently)

✅ Update ProductService without touching UserService
✅ Scale OrderService to 10 replicas when orders spike
✅ Deploy NotificationService every hour if needed
✅ If UserService fails: Others keep running
✅ If one database is slow: Doesn't affect other services

// OrderService needs product info
public class OrderService {
    private readonly HttpClient _httpClient;
    
    public async Task<Order> CreateOrder(CreateOrderDto dto) {
        // Call ProductService
        var product = await _httpClient.GetAsync(
            $"http://product-service:5000/api/products/{dto.ProductId}"
        );
        
        // Create order only if product exists
        var order = new Order {
            ProductId = dto.ProductId,
            Quantity = dto.Quantity,
            CreatedAt = DateTime.UtcNow
        };
        
        await _dbContext.Orders.AddAsync(order);
        await _dbContext.SaveChangesAsync();
        return order;
    }
}

// OrderService publishes event
public class OrderService {
    private readonly IMessageBus _messageBus;
    
    public async Task<Order> CreateOrder(CreateOrderDto dto) {
        var order = new Order {
            ProductId = dto.ProductId,
            Quantity = dto.Quantity,
            CreatedAt = DateTime.UtcNow
        };
        
        await _dbContext.Orders.AddAsync(order);
        await _dbContext.SaveChangesAsync();
        
        // Publish event - NotificationService listens
        await _messageBus.PublishAsync(new OrderCreatedEvent {
            OrderId = order.Id,
            UserId = dto.UserId,
            ProductId = dto.ProductId
        });
        
        return order;
    }
}

// NotificationService listens
public class OrderCreatedEventHandler {
    private readonly IEmailService _emailService;
    
    public async Task Handle(OrderCreatedEvent @event) {
        // Get user email from UserService
        var user = await _userService.GetUserAsync(@event.UserId);
        
        // Send confirmation email
        await _emailService.SendOrderConfirmationAsync(user.Email, @event.OrderId);
    }
}

dotnet-microservices/
├── src/
│   ├── Services/
│   │   ├── UserService/
│   │   │   ├── UserService.Api/
│   │   │   │   ├── Controllers/
│   │   │   │   ├── Services/
│   │   │   │   ├── Data/
│   │   │   │   └── Program.cs
│   │   │   ├── UserService.Domain/
│   │   │   └── UserService.Tests/
│   │   ├── ProductService/
│   │   ├── OrderService/
│   │   └── NotificationService/
│   ├── Shared/
│   │   ├── Events/ (shared event definitions)
│   │   └── Dtos/ (shared DTOs)
├── .github/workflows/
│   └── deploy.yml
├── kubernetes/
│   ├── base/
│   ├── overlays/
│   └── helm-charts/
└── docker-compose.yml

dotnet new globaljson --sdk-version 8.0.0
dotnet new sln -n DotnetMicroservices
dotnet new webapi -n UserService.Api
cd UserService.Api
dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.Npgsql
dotnet add package MassTransit.RabbitMQ

// UserService.Domain/Models/User.cs
public class User
{
    public Guid Id { get; set; }
    public string Email { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string PasswordHash { get; set; }
    public bool IsActive { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? LastLoginAt { get; set; }
}

// UserService.Api/Data/UserDbContext.cs
public class UserDbContext : DbContext
{
    public DbSet<User> Users { get; set; }
    
    public UserDbContext(DbContextOptions<UserDbContext> options) : base(options) { }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>(entity =>
        {
            entity.HasKey(e => e.Id);
            entity.Property(e => e.Email).IsRequired().HasMaxLength(255);
            entity.Property(e => e.FirstName).IsRequired().HasMaxLength(100);
            entity.Property(e => e.PasswordHash).IsRequired();
            
            // Index for lookups
            entity.HasIndex(e => e.Email).IsUnique();
        });
    }
}

// UserService.Api/Services/UserService.cs
public interface IUserService
{
    Task<UserDto> CreateUserAsync(CreateUserDto dto);
    Task<UserDto> GetUserByIdAsync(Guid id);
    Task<UserDto> GetUserByEmailAsync(string email);
    Task UpdateLastLoginAsync(Guid userId);
}

public class UserService : IUserService
{
    private readonly UserDbContext _context;
    private readonly ILogger<UserService> _logger;
    
    public UserService(UserDbContext context, ILogger<UserService> logger)
    {
        _context = context;
        _logger = logger;
    }
    
    public async Task<UserDto> CreateUserAsync(CreateUserDto dto)
    {
        _logger.LogInformation("Creating user: {Email}", dto.Email);
        
        // Check if user exists
        var existingUser = await _context.Users
            .FirstOrDefaultAsync(u => u.Email == dto.Email);
        
        if (existingUser != null)
        {
            _logger.LogWarning("User already exists: {Email}", dto.Email);
            throw new InvalidOperationException("User already exists");
        }
        
        var user = new User
        {
            Id = Guid.NewGuid(),
            Email = dto.Email,
            FirstName = dto.FirstName,
            LastName = dto.LastName,
            PasswordHash = BCrypt.Net.BCrypt.HashPassword(dto.Password),
            IsActive = true,
            CreatedAt = DateTime.UtcNow
        };
        
        _context.Users.Add(user);
        await _context.SaveChangesAsync();
        
        _logger.LogInformation("User created successfully: {UserId}", user.Id);
        
        return MapToDto(user);
    }
    
    public async Task<UserDto> GetUserByIdAsync(Guid id)
    {
        var user = await _context.Users.FindAsync(id);
        
        if (user == null)
        {
            _logger.LogWarning("User not found: {UserId}", id);
            throw new KeyNotFoundException($"User {id} not found");
        }
        
        return MapToDto(user);
    }
    
    public async Task<UserDto> GetUserByEmailAsync(string email)
    {
        var user = await _context.Users
            .FirstOrDefaultAsync(u => u.Email == email);
        
        if (user == null)
        {
            _logger.LogWarning("User not found: {Email}", email);
            throw new KeyNotFoundException($"User {email} not found");
        }
        
        return MapToDto(user);
    }
    
    public async Task UpdateLastLoginAsync(Guid userId)
    {
        var user = await _context.Users.FindAsync(userId);
        if (user != null)
        {
            user.LastLoginAt = DateTime.UtcNow;
            await _context.SaveChangesAsync();
            _logger.LogInformation("Last login updated for user: {UserId}", userId);
        }
    }
    
    private UserDto MapToDto(User user) => new()
    {
        Id = user.Id,
        Email = user.Email,
        FirstName = user.FirstName,
        LastName = user.LastName,
        IsActive = user.IsActive,
        CreatedAt = user.CreatedAt,
        LastLoginAt = user.LastLoginAt
    };
}

// UserService.Api/Controllers/UsersController.cs
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserService _userService;
    private readonly ILogger<UsersController> _logger;
    
    public UsersController(IUserService userService, ILogger<UsersController> logger)
    {
        _userService = userService;
        _logger = logger;
    }
    
    [HttpPost]
    public async Task<ActionResult<UserDto>> CreateUser([FromBody] CreateUserDto dto)
    {
        try
        {
            var user = await _userService.CreateUserAsync(dto);
            return CreatedAtAction(nameof(GetUser), new { id = user.Id }, user);
        }
        catch (InvalidOperationException ex)
        {
            _logger.LogError(ex, "Error creating user");
            return BadRequest(ex.Message);
        }
    }
    
    [HttpGet("{id}")]
    public async Task<ActionResult<UserDto>> GetUser(Guid id)
    {
        try
        {
            var user = await _userService.GetUserByIdAsync(id);
            return Ok(user);
        }
        catch (KeyNotFoundException ex)
        {
            _logger.LogError(ex, "User not found: {UserId}", id);
            return NotFound(ex.Message);
        }
    }
    
    [HttpPost("{id}/login")]
    public async Task<IActionResult> Login(Guid id)
    {
        await _userService.UpdateLastLoginAsync(id);
        return Ok();
    }
}

// UserService.Api/Program.cs
var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Database
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<UserDbContext>(options =>
    options.UseNpgsql(connectionString)
);

// Business logic
builder.Services.AddScoped<IUserService, UserService>();

// Logging
builder.Services.AddLogging(config =>
{
    config.AddConsole();
    config.AddApplicationInsights();
});

// Health checks
builder.Services.AddHealthChecks()
    .AddDbContextCheck<UserDbContext>();

var app = builder.Build();

// Middleware
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseAuthorization();
app.MapControllers();
app.MapHealthChecks("/health");

app.Run();

# UserService/Dockerfile

# Stage 1: Build
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS builder

WORKDIR /src

# Copy project files
COPY ["UserService.Api/UserService.Api.csproj", "UserService.Api/"]
COPY ["UserService.Domain/UserService.Domain.csproj", "UserService.Domain/"]

# Restore dependencies (cached layer)
RUN dotnet restore "UserService.Api/UserService.Api.csproj"

# Copy source code
COPY . .

# Build and publish
RUN dotnet publish "UserService.Api/UserService.Api.csproj" \
    -c Release \
    -o /app/publish \
    --no-restore

# Stage 2: Runtime (Small image)
FROM mcr.microsoft.com/dotnet/aspnet:8.0

WORKDIR /app

# Copy only what we need from builder
COPY --from=builder /app/publish .

# Create non-root user for security
RUN useradd -m -u 1001 dotnetapp && chown -R dotnetapp:dotnetapp /app
USER dotnetapp

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
    CMD curl -f http://localhost:8080/health || exit 1

EXPOSE 8080

# Run with optimizations for containers
ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=false \
    DOTNET_EnableDiagnostics=0

ENTRYPOINT ["dotnet", "UserService.Api.dll"]

# Build Docker image
docker build -t user-service:latest -f UserService/Dockerfile .

# Run container
docker run -d \
  --name user-service \
  -p 8080:8080 \
  -e "ConnectionStrings__DefaultConnection=Server=postgres;Database=users;User=postgres;Password=password;" \
  user-service:latest

# Test
curl http://localhost:8080/health
curl http://localhost:8080/swagger

# Check logs
docker logs user-service

# Stop
docker stop user-service
docker rm user-service

# Create resource group
az group create --name microservices-rg --location eastus

# Create ACR
az acr create \
  --resource-group microservices-rg \
  --name myacr \
  --sku Standard

# Login to ACR
az acr login --name myacr

# Tag image
docker tag user-service:latest myacr.azurecr.io/user-service:latest
docker tag user-service:latest myacr.azurecr.io/user-service:v1.0.0

# Push to ACR
docker push myacr.azurecr.io/user-service:latest
docker push myacr.azurecr.io/user-service:v1.0.0

# Verify
az acr repository list --name myacr --output table

# Create AKS cluster (takes 5-10 minutes)
az aks create \
  --resource-group microservices-rg \
  --name microservices-cluster \
  --node-count 3 \
  --vm-set-type VirtualMachineScaleSets \
  --load-balancer-sku standard \
  --attach-acr myacr \
  --network-plugin azure \
  --zones 1 2 3

# Get credentials
az aks get-credentials \
  --resource-group microservices-rg \
  --name microservices-cluster

# Verify connection
kubectl cluster-info
kubectl get nodes

# kubernetes/namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: microservices

# kubernetes/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
  namespace: microservices
data:
  aspnetcore_environment: "Production"
  logging_level: "Information"
  feature_flags: "new_ui=true,beta_api=false"

# Create secret
kubectl create secret generic app-secrets \
  --from-literal=db_password=<your-secure-password> \
  --from-literal=jwt_secret=<your-jwt-secret> \
  -n microservices

# kubernetes/user-service-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
  namespace: microservices
spec:
  replicas: 3  # Always run 3 replicas
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "8080"
        prometheus.io/path: "/metrics"
    spec:
      containers:
      - name: user-service
        image: myacr.azurecr.io/user-service:latest
        imagePullPolicy: Always
        ports:
        - name: http
          containerPort: 8080
        env:
        - name: ASPNETCORE_ENVIRONMENT
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: aspnetcore_environment
        - name: ConnectionStrings__DefaultConnection
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: db_connection_string
        - name: JWT_SECRET
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: jwt_secret
        
        # Resource requests (important for cost!)
        resources:
          requests:
            cpu: 100m
            memory: 256Mi
          limits:
            cpu: 500m
            memory: 512Mi
        
        # Health checks
        livenessProbe:
          httpGet:
            path: /health
            port: http
          initialDelaySeconds: 10
          periodSeconds: 30
          timeoutSeconds: 3
        
        readinessProbe:
          httpGet:
            path: /health/ready
            port: http
          initialDelaySeconds: 5
          periodSeconds: 10
          timeoutSeconds: 2

# kubernetes/user-service-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: user-service
  namespace: microservices
spec:
  type: ClusterIP  # Internal only
  selector:
    app: user-service
  ports:
  - name: http
    port: 5000
    targetPort: http
    protocol: TCP

# kubernetes/ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api-ingress
  namespace: microservices
spec:
  ingressClassName: nginx
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /users
        pathType: Prefix
        backend:
          service:
            name: user-service
            port:
              number: 5000
      - path: /products
        pathType: Prefix
        backend:
          service:
            name: product-service
            port:
              number: 5000

# Apply manifests
kubectl apply -f kubernetes/namespace.yaml
kubectl apply -f kubernetes/configmap.yaml
kubectl apply -f kubernetes/user-service-deployment.yaml
kubectl apply -f kubernetes/user-service-service.yaml
kubectl apply -f kubernetes/ingress.yaml

# Check status
kubectl get pods -n microservices
kubectl get svc -n microservices
kubectl get ingress -n microservices

# View logs
kubectl logs -f deployment/user-service -n microservices

# Port forward (test locally)
kubectl port-forward svc/user-service 5000:5000 -n microservices

# Then curl: http://localhost:5000/api/users

# .github/workflows/deploy-user-service.yml
name: Build and Deploy UserService

on:
  push:
    branches: [ main ]
    paths:
      - 'src/Services/UserService/**'
      - '.github/workflows/deploy-user-service.yml'
  pull_request:
    branches: [ main ]

env:
  REGISTRY: myacr.azurecr.io
  IMAGE_NAME: user-service

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    
    steps:
    - name: Checkout code
      uses: actions/checkout@v3
    
    - name: Setup .NET
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: '8.0.x'
    
    - name: Restore dependencies
      run: |
        cd src/Services/UserService
        dotnet restore
    
    - name: Build
      run: |
        cd src/Services/UserService
        dotnet build --configuration Release --no-restore
    
    - name: Run tests
      run: |
        cd src/Services/UserService
        dotnet test --configuration Release --no-restore --no-build
    
    - name: Run code analysis (optional)
      run: |
        cd src/Services/UserService
        dotnet build --configuration Release --no-restore /p:EnforceCodeStyleInBuild=true

  docker-build-push:
    needs: build-and-test
    runs-on: ubuntu-latest
    if: github.event_name == 'push'
    
    steps:
    - name: Checkout code
      uses: actions/checkout@v3
    
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v2
    
    - name: Log in to Azure Container Registry
      uses: azure/docker-login@v1
      with:
        login-server: ${{ env.REGISTRY }}
        username: ${{ secrets.ACR_USERNAME }}
        password: ${{ secrets.ACR_PASSWORD }}
    
    - name: Extract metadata
      id: meta
      run: |
        echo "tags=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest" >> $GITHUB_OUTPUT
        echo "tags=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
    
    - name: Build and push Docker image
      uses: docker/build-push-action@v4
      with:
        context: .
        file: ./src/Services/UserService/Dockerfile
        push: true
        tags: ${{ steps.meta.outputs.tags }}
        cache-from: type=registry,ref=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:buildcache
        cache-to: type=registry,ref=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:buildcache,mode=max

  deploy-to-aks:
    needs: docker-build-push
    runs-on: ubuntu-latest
    if: github.event_name == 'push'
    
    steps:
    - name: Checkout code
      uses: actions/checkout@v3
    
    - name: Set up kubectl
      uses: azure/setup-kubectl@v3
    
    - name: Get AKS credentials
      uses: azure/aks-set-context@v3
      with:
        admin: 'false'
        cluster-name: microservices-cluster
        resource-group: microservices-rg
        use-kubelogin: true
    
    - name: Deploy to Kubernetes
      run: |
        kubectl set image deployment/user-service \
          user-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:$(git rev-parse --short HEAD) \
          -n microservices
        
        kubectl rollout status deployment/user-service -n microservices
    
    - name: Verify deployment
      run: |
        kubectl get pods -n microservices
        kubectl get svc -n microservices

# Get ACR credentials
az acr credential show --name myacr --query passwords[0].value -o tsv

# In GitHub:
# Settings → Secrets and variables → Actions → New repository secret
# ACR_USERNAME: (from credentials)
# ACR_PASSWORD: (from credentials)

// UserService.Api/Program.cs
builder.Services.AddApplicationInsightsTelemetry();

// In appsettings.json:
{
  "ApplicationInsights": {
    "InstrumentationKey": "your-instrumentation-key"
  }
}

public class OrderCreatedEventHandler
{
    private readonly TelemetryClient _telemetryClient;
    
    public async Task Handle(OrderCreatedEvent @event)
    {
        var properties = new Dictionary<string, string>
        {
            { "UserId", @event.UserId.ToString() },
            { "OrderId", @event.OrderId.ToString() },
            { "ProductId", @event.ProductId.ToString() }
        };
        
        var metrics = new Dictionary<string, double>
        {
            { "OrderQuantity", @event.Quantity }
        };
        
        _telemetryClient.TrackEvent("OrderCreated", properties, metrics);
    }
}

dotnet add package prometheus-net

// Program.cs
app.UseHttpMetrics();
app.MapMetrics();

// Endpoint: http://localhost:8080/metrics

scrape_configs:
  - job_name: 'user-service'
    static_configs:
      - targets: ['user-service:8080']
    metrics_path: '/metrics'

// Assumes ProductService is always available
var product = await _httpClient.GetAsync("http://product-service:5000/api/products/1");

try
{
    var product = await _httpClient.GetAsync(
        "http://product-service:5000/api/products/1",
        timeout: TimeSpan.FromSeconds(5)
    );
    
    if (!product.IsSuccessStatusCode)
    {
        _logger.LogWarning("ProductService returned {StatusCode}", product.StatusCode);
        return StatusCode(503, "Service unavailable");
    }
}
catch (HttpRequestException ex)
{
    _logger.LogError(ex, "ProductService unreachable");
    return StatusCode(503, "Product service unavailable");
}

resources: {}  # Unlimited!

resources:
  requests:
    cpu: 100m      # Guaranteed
    memory: 256Mi
  limits:
    cpu: 500m      # Maximum
    memory: 512Mi

// UserService directly calls ProductService
var product = await _httpClient.GetAsync("http://product-service/products/1");
var user = await _httpClient.GetAsync("http://user-service/users/1");
// Both must succeed or entire operation fails

// OrderService publishes event
await _messageBus.PublishAsync(new OrderCreatedEvent { OrderId, UserId, ProductId });

// ProductService listens independently
// UserService listens independently
// If one fails, others still work

# No health checks - Kubernetes doesn't know when pod is unhealthy

livenessProbe:
  httpGet:
    path: /health
    port: 8080
  periodSeconds: 30

readinessProbe:
  httpGet:
    path: /health/ready
    port: 8080
  periodSeconds: 10

var connectionString = "Server=localhost;Password=SuperSecretPassword123";

// In appsettings.json
var connectionString = configuration.GetConnectionString("DefaultConnection");

// Connection string from Kubernetes Secret, not code

// OrderService/Events/OrderCreatedEvent.cs
public class OrderCreatedEvent
{
    public Guid OrderId { get; set; }
    public Guid UserId { get; set; }
    public Guid ProductId { get; set; }
    public int Quantity { get; set; }
    public DateTime CreatedAt { get; set; }
}

// OrderService/Services/OrderService.cs
public class OrderService
{
    private readonly OrderDbContext _dbContext;
    private readonly IPublishEndpoint _publishEndpoint;
    private readonly ILogger<OrderService> _logger;
    
    public async Task<OrderDto> CreateOrderAsync(CreateOrderDto dto)
    {
        _logger.LogInformation("Creating order for user {UserId}", dto.UserId);
        
        var order = new Order
        {
            Id = Guid.NewGuid(),
            UserId = dto.UserId,
            ProductId = dto.ProductId,
            Quantity = dto.Quantity,
            Status = OrderStatus.Pending,
            CreatedAt = DateTime.UtcNow
        };
        
        // Save to database
        _dbContext.Orders.Add(order);
        await _dbContext.SaveChangesAsync();
        
        // Publish event (asynchronously)
        try
        {
            await _publishEndpoint.Publish(new OrderCreatedEvent
            {
                OrderId = order.Id,
                UserId = order.UserId,
                ProductId = order.ProductId,
                Quantity = order.Quantity,
                CreatedAt = order.CreatedAt
            });
            
            _logger.LogInformation("Order event published: {OrderId}", order.Id);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to publish order event for {OrderId}", order.Id);
            // Still return success - order was saved
            // Event will be retried
        }
        
        return MapToDto(order);
    }
}

// NotificationService/Consumers/OrderCreatedConsumer.cs
public class OrderCreatedConsumer : IConsumer<OrderCreatedEvent>
{
    private readonly IEmailService _emailService;
    private readonly IUserServiceClient _userServiceClient;
    private readonly ILogger<OrderCreatedConsumer> _logger;
    
    public async Task Consume(ConsumeContext<OrderCreatedEvent> context)
    {
        var @event = context.Message;
        
        try
        {
            _logger.LogInformation("Processing order created event: {OrderId}", @event.OrderId);
            
            // Get user details
            var user = await _userServiceClient.GetUserAsync(@event.UserId);
            
            // Send confirmation email
            await _emailService.SendOrderConfirmationAsync(
                user.Email,
                @event.OrderId,
                @event.Quantity
            );
            
            _logger.LogInformation("Order confirmation sent to {Email}", user.Email);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to process order created event: {OrderId}", @event.OrderId);
            throw;  // Let message bus retry
        }
    }
}

User creates order
    ↓
OrderService saves to database
    ↓
OrderService publishes OrderCreatedEvent
    ↓
NotificationService receives event (in its own container, independently)
    ↓
NotificationService calls UserService for email
    ↓
NotificationService sends email
    ↓
If email fails: OrderService still succeeded
    ↓
If UserService is down: Order still created, notification retried later

// Order created
await _publishEndpoint.Publish(new OrderCreatedEvent(...));

// Notification service listens
await _publishEndpoint.Publish(new NotificationSentEvent(...));

// Notification failed - publish rollback
await _publishEndpoint.Publish(new OrderCancelledEvent(...));

public class OrderSaga : StateMachine<OrderState>
{
    public State Pending { get; private set; }
    public State NotificationSent { get; private set; }
    public State Completed { get; private set; }
    
    // Define transitions and compensation logic
}

Order created immediately
Notification sent later
If notification fails, manual retry or accept loss

var response = await _httpClient.GetAsync("http://user-service:5000/users/1");

var user = await _grpcClient.GetUserAsync(new GetUserRequest { Id = userId });

await _messageBus.PublishAsync(new UserRequiredEvent(...));

1. Centralized Logging (Loki/ELK)
   - All logs in one place
   - Query by OrderId across all services

2. Distributed Tracing (Jaeger/Zipkin)
   - Follow request through all services
   - See which service is slow

3. Application Insights
   - C# code level monitoring
   - See exceptions, slow methods

4. kubectl logs
   - See container output
   - Debug Kubernetes issues

5. Port forwarding
   - Debug locally against prod service
   - kubectl port-forward pod-name 5000:5000

CPU > 70% consistently → Add more pods
Memory > 80% → Increase memory requests
Request latency > 1s → Optimize code or scale horizontally
Error rate > 0.1% → Investigate, then scale if needed

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: user-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: user-service
  minReplicas: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80