.NET Core Microservices and Azure Kubernetes Service

 

A Comprehensive Technical Guide for Enterprise Architects

---

---

Executive Summary

Deploying .NET Core microservices on Azure Kubernetes Service (AKS) has become the enterprise standard for building scalable, resilient, cloud-native applications within the Microsoft ecosystem.

For senior .NET developers and architects, mastering this architecture unlocks high-impact cloud engineering roles, where organizations expect deep expertise in:

• Containerization
• Kubernetes orchestration
• Distributed systems design
• Infrastructure as Code (IaC)

AKS brings together:

• ASP.NET Core high-performance runtime
• Kubernetes self-healing orchestration
• Microsoft Azure managed cloud services

The result is a platform capable of automatic scaling, rolling deployments, service discovery, distributed tracing, and workload isolation—all essential for modern enterprise systems.

---

Core Architecture: Internal Mechanics & Patterns

The Microservices Foundation on AKS

AKS provides a managed Kubernetes control plane, removing the operational burden of managing masters while preserving full control over worker nodes and workloads.

A production-grade AKS microservices architecture typically includes:

• Containerized services
  Each microservice runs as a Docker container inside Kubernetes Pods.
• Azure CNI with Cilium
  Pods receive VNet IPs, enabling native network policies, observability, and zero-trust networking.
• Ingress + API Gateway pattern
  A centralized ingress exposes HTTP/HTTPS entry points.
• Externalized state
  Stateless services persist data to Azure SQL, Cosmos DB, Redis, or Service Bus.

---

API Gateway & Request Routing

The Ingress Controller acts as the edge gateway, handling:

• Request routing
• SSL/TLS termination
• Authentication & authorization
• Rate limiting and IP filtering
• Request aggregation

For large enterprises, multiple ingress controllers are often deployed per cluster to isolate environments, tenants, or workloads.

---

Namespace Strategy & Service Organization

Namespaces should align with bounded contexts (DDD):

• order-fulfillment
• payments
• inventory
• platform-observability

This provides:

• Clear RBAC boundaries
• Resource quotas per domain
• Improved operational clarity

---

Communication Patterns

A hybrid communication model is recommended:

Synchronous (REST / HTTP)

• Read-heavy operations
• Immediate responses

Asynchronous (Messaging)

• State changes
• Long-running workflows

Technologies like RabbitMQ + MassTransit enable loose coupling and fault tolerance while avoiding cascading failures.

---

Service Discovery & Health Management

• Kubernetes Services provide stable DNS-based discovery
• Liveness probes restart failed containers
• Readiness probes control traffic flow
• ASP.NET Core Health Checks integrate natively with Kubernetes

---

Technical Implementation: Modern .NET Practices

Health Checks (ASP.NET Core)

builder.Services.AddHealthChecks()
    .AddCheck("self", () => HealthCheckResult.Healthy());

---

Kubernetes Deployment (Production-Ready)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
  namespace: order-fulfillment
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
        - name: order-service
          image: myregistry.azurecr.io/order-service:1.0.0
          ports:
            - containerPort: 8080
          resources:
            requests:
              cpu: "250m"
              memory: "256Mi"
            limits:
              cpu: "500m"
              memory: "512Mi"
          readinessProbe:
            httpGet:
              path: /health/ready
              port: 8080
          livenessProbe:
            httpGet:
              path: /health/live
              port: 8080

---

Distributed Tracing (Application Insights + OpenTelemetry)

builder.Services.AddApplicationInsightsTelemetry();

builder.Services.AddOpenTelemetry()
    .WithTracing(tracing =>
    {
        tracing
            .AddAspNetCoreInstrumentation()
            .AddHttpClientInstrumentation()
            .AddAzureMonitorTraceExporter();
    });

This enables end-to-end request tracing across microservices.

---

Resilient Service-to-Service Calls (Polly)

builder.Services.AddHttpClient<IOrderClient, OrderClient>()
    .AddTransientHttpErrorPolicy(p =>
        p.WaitAndRetryAsync(3, retry =>
            TimeSpan.FromSeconds(Math.Pow(2, retry))))
    .AddTransientHttpErrorPolicy(p =>
        p.CircuitBreakerAsync(5, TimeSpan.FromSeconds(30)));

---

Event-Driven Architecture (MassTransit + RabbitMQ)

builder.Services.AddMassTransit(x =>
{
    x.AddConsumer<OrderCreatedConsumer>();

    x.UsingRabbitMq((context, cfg) =>
    {
        cfg.Host("rabbitmq://rabbitmq");
        cfg.ConfigureEndpoints(context);
    });
});

public class OrderCreatedConsumer : IConsumer<OrderCreatedEvent>
{
    public async Task Consume(ConsumeContext<OrderCreatedEvent> context)
    {
        // Persist order and publish downstream events
    }
}

---

Distributed Caching (Redis – Cache-Aside)

builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration =
        builder.Configuration.GetConnectionString("Redis");
});

---

Scaling & Performance

Horizontal Pod Autoscaler (HPA)

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
spec:
  minReplicas: 3
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70

---

Common Pitfalls (From Real Systems)

• Shared databases across services
• Long synchronous REST chains
• No observability or tracing
• Poor CPU/memory limits
• Ignoring network policies

---

Optimization Tricks Used in Production

• Spot node pools for non-critical workloads (~70% cost savings)
• Pod Disruption Budgets
• Vertical Pod Autoscaler
• Docker layer caching
• Fine-tuned readiness vs liveness probes
• GitOps with Terraform + Argo CD

---

When AKS Microservices Make Sense

Scenario	Recommendation
10+ services	✅ AKS
High traffic	✅ AKS
Multiple teams	✅ AKS
Small MVP	❌ Monolith
Strong ACID needs	❌ Microservices

---

Final Takeaway

AKS + .NET Core is a power tool—not a starter kit.

When used correctly, it delivers scalability, resilience, and deployment velocity unmatched by traditional architectures. When misused, it introduces unnecessary complexity.

For enterprise systems with multiple teams, frequent releases, and global scale, this architecture is absolutely worth the investment.