Kubernetes Deployment — Complete Guide

Introduction

Kubernetes Deployment — Complete Guide is essential for .NET developers building ShopNest.Live Enterprise Real-Time Communication Platform — Toolliyo's 100-article SignalR & SSE master path covering hubs, SSE streaming, WebSockets, Redis backplane, Azure SignalR, Kubernetes, and enterprise live apps. Every article includes architecture diagrams, scaling discussion, security guidance, and two ultra-detailed real-world examples.

In Indian delivery projects (TCS, Infosys, Wipro), interviewers expect kubernetes deployment with real Swiggy live tracking, Zerodha tickers, HDFC fraud alerts, and Azure SignalR at scale — not toy demos. This article delivers production depth on CLOUD.

After this article you will

• Explain Kubernetes Deployment in plain English and in real-time architecture terms
• Implement kubernetes deployment in ShopNest.Live (CLOUD)
• Compare polling vs WebSocket vs SSE vs SignalR and pick the right transport
• Answer fresher and senior SignalR/SSE system design interview questions confidently
• Connect this lesson to Article 73 and the 100-article SignalR & SSE roadmap

Prerequisites

• Software: .NET 10 SDK, VS 2022 or VS Code, Redis (Docker) for backplane lessons
• Knowledge: ASP.NET Core Web API
• Previous: Article 71 — Dockerizing SignalR Apps — Complete Guide
• Time: 28 min reading + 30–45 min hands-on

Concept deep-dive

Level 1 — Analogy

Containers spin up more SignalR servers; Azure SignalR Service holds persistent connections while your pods stay stateless.

Level 2 — Technical

Kubernetes Deployment scales real-time — Redis pub/sub backplane, Azure SignalR Service, K8s replicas, and message bus integration for cross-service events.

Level 3 — Distributed systems view

[React / Angular / Blazor Client]
       ▼
[HTTPS → negotiate → WebSocket / SSE / Long Poll]
       ▼
[Load Balancer → SignalR Hub Pod 1..N]
       ▼
[Redis Backplane / Azure SignalR Service]
       ▼
[Web API + EF Core + RabbitMQ/Kafka]
       ▼
[Serilog · Prometheus · Grafana · OpenTelemetry]

Project structure

ShopNest.Live/
├── ShopNest.Live.Api/       ← SignalR hubs + SSE endpoints
├── ShopNest.Live.Client/    ← React / Angular SPA
├── Hubs/                    ← ChatHub, OrderTrackingHub
├── Services/                ← IOrderTrackingService (DI)
├── Program.cs               ← AddSignalR + Redis backplane
└── appsettings.json         ← Redis, Azure SignalR connection

Hands-on implementation — CLOUD

Implement Kubernetes Deployment in ShopNest.Live for CLOUD: hub or SSE endpoint, client connection, groups/auth, and verify with browser DevTools WS/SSE tab.

1. Open ShopNest.Live.Api and add or update the hub/SSE endpoint for this lesson.
2. Register SignalR + optional Redis backplane in Program.cs.
3. Wire the React/Angular/Blazor client with automatic reconnect.
4. Add [Authorize] and JWT via accessTokenFactory on the client.
5. Test with two browser tabs — verify group broadcast and reconnect after network drop.

Anti-pattern (polling only, Clients.All, no backplane)

// ❌ BAD — polling every 2s, no scale-out, no auth
setInterval(async () => {
  const res = await fetch('/api/orders/status');
  updateUI(await res.json());
}, 2000);
// 10k users = 5k requests/sec — database meltdown

Production-style SignalR hub / SSE endpoint

// ✅ PRODUCTION — Kubernetes Deployment on ShopNest.Live (CLOUD)
builder.Services.AddSignalR().AddStackExchangeRedis(configuration["Redis"]);
app.MapHub<OrderTrackingHub>("/hubs/orders");
// Server: await Clients.Group($"order-{id}").SendAsync("LocationUpdated", dto);
// Client: connection.on('LocationUpdated', updateMap);

Complete example

// Kubernetes Deployment — ShopNest.Live scale-out
builder.Services.AddSignalR().AddStackExchangeRedis(redisConn);

Real-time communication fundamentals

Kubernetes Deployment — technology focus: SIGNALR, module category: CLOUD.

SignalR negotiates WebSockets, SSE, or long-polling automatically — bidirectional hub methods and groups.

SignalR vs SSE vs WebSockets

• Raw WebSockets — maximum control; you own protocol, reconnection, and scaling.
• SSE — use when only server pushes (stock tickers, live logs, notification streams).
• SignalR — default for ASP.NET Core apps needing hubs, groups, JWT auth, and Redis backplane.

Browser ──negotiate──► SignalR Hub
         ◄── WebSocket / SSE / Long Poll ──►
Redis Backplane ◄──► Multiple API instances (ShopNest.Live)

Connection lifecycle

1. Client calls /negotiate (SignalR) or opens EventSource (SSE)
2. Server assigns connection ID / stream ID
3. Messages flow — hub methods, groups, or SSE events
4. Disconnect → automatic reconnect with exponential backoff
5. Scale-out: Redis publishes to all server instances

SignalR internal pipeline

Hub → IHubContext for server-initiated messages. Connection ID maps to user via Context.UserIdentifier. Groups like order-{id} isolate Swiggy-style tracking channels.

public class OrderTrackingHub : Hub
{
    public async Task JoinOrder(string orderId) =>
        await Groups.AddToGroupAsync(Context.ConnectionId, $"order-{orderId}");
    public async Task UpdateLocation(string orderId, double lat, double lng) =>
        await Clients.Group($"order-{orderId}").SendAsync("LocationUpdated", lat, lng);
}

SSE streaming (when applicable)

app.MapGet("/sse/prices", async (HttpResponse res) => {
    res.Headers.ContentType = "text/event-stream";
    await foreach (var tick in _priceStream.ReadAsync())
        await res.WriteAsync($"data: {tick}

");
});

Browser: const es = new EventSource('/sse/prices'); es.onmessage = e => updateChart(JSON.parse(e.data));

Scaling and distributed systems

• Redis backplane — synchronizes messages across SignalR server instances
• Azure SignalR Service — managed connection layer for 100k+ concurrent users
• Sticky sessions — only needed without backplane; avoid in Kubernetes
• Kafka/RabbitMQ — domain events fan-out to notification workers

Performance and security

• Enable message compression for large payloads
• JWT in query string or accessTokenFactory for WebSocket auth
• Rate limit hub invocations per connection ID
• CORS: allow credentials only for trusted origins
• Monitor connection count, message throughput, reconnect rate in Grafana

Real-world use case 1 — Swiggy Live Order Tracking

Domain: Food Delivery. SignalR pushes rider GPS and ETA to React dashboard — same pattern as Uber Eats order map updates.

Real-world use case 2 — Flipkart Flash Sale Counter

Domain: E-Commerce. WebSocket + SignalR broadcast inventory counts to 50k concurrent viewers during Big Billion Days.

Kubernetes and cloud deployment

# ShopNest.Live SignalR on AKS
apiVersion: apps/v1
kind: Deployment
metadata:
  name: shopnest-live-api
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: api
        env:
        - name: Azure__SignalR__ConnectionString
          valueFrom:
            secretKeyRef:
              name: signalr-secret
              key: connectionString

Observability

Instrument with OpenTelemetry: trace hub method duration, connection churn, Redis publish latency. Serilog + Prometheus + Grafana dashboards for production ShopNest.Live.

Integration testing SignalR

[Fact]
public async Task JoinOrder_AddsConnectionToGroup()
{
    // WebApplicationFactory + TestServer for hub integration tests
    await hub.JoinOrder("ORD-123");
    // Assert connection added to group order-ORD-123
}

Pattern recognition

One-way feeds → SSE. Chat, tracking, collaboration → SignalR. Custom binary protocol at massive scale → raw WebSockets. Multi-instance → Redis or Azure SignalR Service.

Scaling notes

Before the second API instance, add Redis backplane or Azure SignalR Service. Monitor active connections per pod; use HPA on custom metrics in Kubernetes.

Common errors & fixes

• Broadcasting to Clients.All for order-specific updates — Use Groups: await Groups.AddToGroupAsync(connectionId, $"order-{id}");
• Missing JWT token on WebSocket negotiate — Pass accessTokenFactory in JS client or ?access_token= query with OnMessageReceived.
• No reconnection handler on client disconnect — connection.onclose + start() with exponential backoff; show "Reconnecting…" UI.
• Deploying multiple instances without backplane — Messages sent on server A never reach clients on server B — add Redis or Azure SignalR.

Best practices

• 🟢 Use Groups instead of Clients.All for targeted broadcasts
• 🟢 Enable Redis backplane or Azure SignalR before second API instance
• 🟡 Prefer SSE for one-way dashboards; SignalR for bidirectional features
• 🟡 Implement client reconnection with exponential backoff
• 🔴 Never expose hub methods without [Authorize] in production
• 🔴 Monitor connection count and message throughput in Grafana

Interview questions

Fresher level

Q1: Explain Kubernetes Deployment in a system design interview.
A: Compare polling vs WebSocket vs SSE vs SignalR; state when you pick each; mention Redis/Azure scale-out for ShopNest.Live.

Q2: How does SignalR scale horizontally?
A: Redis backplane or Azure SignalR Service publishes messages to all server instances so any pod can reach any client.

Q3: SignalR vs raw WebSockets?
A: SignalR gives hubs, groups, auth integration, transport fallback — WebSockets give full protocol control at the cost of more plumbing.

Mid / senior level

Q4: When would you choose SSE over SignalR?
A: One-way streams: stock tickers, live logs, notification feeds — simpler HTTP, auto-reconnect in EventSource.

Q5: How do you authenticate SignalR connections?
A: JWT via accessTokenFactory; [Authorize] on hub; Context.UserIdentifier for user-targeted messages; OnMessageReceived for query token.

Q6: What metrics do you monitor in production?
A: Active connections, messages/sec, reconnect rate, hub method latency, Redis publish lag, negotiate failures.

Coding round

Implement a SignalR hub method that adds a connection to group order-{id} and broadcasts rider GPS updates only to that group.

public async Task JoinOrder(string orderId)
{
    await Groups.AddToGroupAsync(Context.ConnectionId, $"order-{orderId}");
}
public async Task BroadcastLocation(string orderId, double lat, double lng)
    => await Clients.Group($"order-{orderId}").SendAsync("LocationUpdated", lat, lng);

Summary & next steps

• Article 72: Kubernetes Deployment — Complete Guide
• Module: Module 8: Cloud and DevOps · Level: ADVANCED · Tech: SIGNALR
• Applied to ShopNest.Live — CLOUD

Previous: Dockerizing SignalR Apps — Complete Guide
Next: Azure SignalR Deployment — Complete Guide

Practice: Add one small real-time feature — commit with feat(signalr): article-72.

FAQ