Deploying Scalable ASP.NET Core Apps on Kubernetes

Deploying Scalable ASP.NET Core Apps on Kubernetes

Kubernetes has become the de facto standard for deploying and managing containerized applications at scale. In this post, we will see how to build a scalable ASP .NET Core app and deploy it on a Kubernetes cluster.

Benefits of Kubernetes for ASP .NET Core

Here are some key benefits Kubernetes provides for ASP .NET Core workloads:

  • Automated scaling - Kubernetes can automatically scale ASP .NET Core deployments up and down based on demand. This allows for handling large traffic spikes gracefully.

  • Load balancing - The Kubernetes service abstraction provides load balancing across ASP .NET Core pod replicas. Requests are evenly distributed for maximum resource utilization.

  • High availability - Kubernetes ensures high availability by distributing ASP .NET Core instances across nodes and automatically rescheduling failed containers.

  • Simplified deployment - Kubernetes enables deploying new ASP .NET Core versions through rolling updates with zero downtime. Infrastructure changes are minimal.

  • Observability - Kubernetes provides visibility into ASP .NET Core app metrics, logs, and tracing for monitoring and troubleshooting.

  • Cross-platform - Kubernetes is consistent across on-premise and cloud environments like AWS, Azure, and GCP. ASP .NET Core apps can be deployed anywhere.

Building a Sample ASP .NET Core App

We will build a simple ASP .NET Core web API for this demo that performs CRUD operations against a PostgreSQL database. It uses .NET 6 and Entity Framework Core.

The API has two endpoints:

  • GET /books - Get all books

  • POST /books - Create a new book

Here is a code snippet showing the BooksController:

// Omitted - Namespace declarations


public class BooksController : ControllerBase


private readonly BookContext _context;

public BooksController(BookContext context)


_context = context;



public async Task<IActionResult> GetBooks()


return Ok(await _context.Books.ToListAsync());



public async Task<IActionResult> AddBook(Book book)



await _context.SaveChangesAsync();

return CreatedAtAction(nameof(GetBooks), new { id = book.Id }, book);



The BookContext uses EF Core to connect with a PostgreSQL database to store book records.

Dockerizing the ASP .NET Core API

The first step is to Dockerize the ASP .NET Core API to deploy instances consistently across environments.

Here is a sample Dockerfile:

FROM AS base


FROM AS build


COPY . .

RUN dotnet restore "BooksAPI.csproj"

RUN dotnet build "BooksAPI.csproj" -c Release -o /app/build

FROM build AS publish

RUN dotnet publish "BooksAPI.csproj" -c Release -o /app/publish

FROM base AS final


COPY --from=publish /app/publish .

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

This multi-stage Dockerfile builds the ASP .NET Core app as a Linux container image.

Configuring the Kubernetes Cluster

The next step is setting up a Kubernetes cluster on AWS EKS or Azure AKS and installing kubectl CLI tool.

Some key resources need to be created:

  • Kubernetes Deployment - For deploying the ASP .NET Core pods

  • Service - For exposing the Deployment

  • Ingress - For routing external traffic to the Service

  • ConfigMap - For application config

  • Secret - For storing sensitive data like DB credentials

Here is an example deployment manifest:

apiVersion: apps/v1

kind: Deployment


name: books-api


replicas: 3



app: books-api




app: books-api



- name: books-api

image: booksapi:v1


- containerPort: 80


- name: ConnectionStrings__BookDb



name: bookdb-secret

key: connection_string

This deploys 3 ASP .NET Core API container replicas and injects the database connection string from a Kubernetes secret.

Scaling the Application

One of the key advantages of Kubernetes is the ability to scale applications seamlessly.

Scaling the number of ASP .NET Core API replicas is as simple as changing the replicas field and reapplying the deployment. Kubernetes will handle starting new pods to match the desired count.

For autoscaling based on demand, Kubernetes Horizontal Pod Autoscaler can be used. It automatically scales the number of pods between minimum and maximum limits based on CPU or memory utilization.

Handling Traffic with Ingress

A Kubernetes Ingress is used to route external traffic to the ASP .NET Core API. The Ingress works as a reverse proxy and load balancer.

For example:


kind: Ingress


name: books-ingress



- http:


- path: /api/books

pathType: Prefix



name: books-api-service


number: 80

This will route external requests /api/books to the internal Service, exposing the ASP .NET Core API pods. Multiple APIs can be hosted on the same domain by using path-based routing.

Final Words

Deploying scalable and resilient ASP .NET Core applications is critical for enterprises seeking robust web solutions. Companies can build and run ASP .NET development services and Kubernetes at scale by leveraging ASP .NET Core workloads.

In this post, we deployed a sample ASP .NET Core API to a Kubernetes cluster. The benefits of Kubernetes for ASP .NET Core are numerous - automated scaling, load balancing, high availability, simplified deployment, and cross-platform portability.

For production workloads, aspects like monitoring, logs aggregation, security, and data persistence must also be considered. However, with expert ASP .NET development teams, these can be implemented following industry best practices. Kubernetes provides a modern way to deploy enterprise-grade ASP .NET Core applications and seamlessly handle scale. By partnering with specialized ASP.NET development services firms, robust and future-ready ASP .NET Core solutions can be built on Kubernetes.