Kubernetes  

How to Deploy ASP.NET Core App Using Kubernetes Step by Step

Introduction

In modern cloud-native development, deploying applications in a scalable, resilient, and maintainable way is essential. One of the most widely adopted solutions for this is Kubernetes, especially when combined with ASP.NET Core applications.

Kubernetes provides powerful orchestration capabilities that help manage containerized applications efficiently. When used with ASP.NET Core, it enables developers to build highly available, scalable, and production-ready systems.

In this guide, we will walk through how to deploy an ASP.NET Core application using Kubernetes step by step, with clear explanations and practical examples.

Understanding Kubernetes in the Context of .NET Applications

Kubernetes is an open-source container orchestration platform designed to automate the deployment, scaling, and management of applications.

It plays a crucial role in:

  • Managing container lifecycles

  • Scaling applications based on demand

  • Ensuring application availability

For ASP.NET Core applications, Kubernetes acts as a runtime environment that ensures your application runs reliably across different environments.

Understanding ASP.NET Core for Containerized Deployment

ASP.NET Core is a cross-platform framework that is well-suited for container-based deployments. Its lightweight nature and built-in support for dependency injection, configuration, and logging make it ideal for microservices and cloud-native applications.

When packaged using Docker, ASP.NET Core applications can be easily deployed to Kubernetes clusters.

Prerequisites for Kubernetes Deployment

Before starting, ensure the following tools are installed and configured:

  • .NET SDK

  • Docker

  • Kubernetes (Minikube or cloud cluster)

  • kubectl CLI

These tools are required to build, containerize, and deploy your application.

Step 1: Create an ASP.NET Core Application

dotnet new webapi -n MyK8sApp
cd MyK8sApp

Code Explanation

  • dotnet new webapi creates a new ASP.NET Core Web API project

  • -n MyK8sApp assigns a project name

  • cd MyK8sApp navigates into the project directory

Run the application to verify it works correctly:

dotnet run

Code Explanation

  • dotnet run builds and runs the application locally

  • This step ensures the project is functioning before containerization

Step 2: Create a Dockerfile

FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /src
COPY . .
RUN dotnet restore
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyK8sApp.dll"]

Code Explanation

  • FROM aspnet:7.0 defines the runtime image

  • WORKDIR /app sets the working directory

  • EXPOSE 80 exposes port 80 for the container

  • FROM sdk:7.0 is used for building the application

  • dotnet restore installs dependencies

  • dotnet publish compiles and prepares the app for deployment

  • ENTRYPOINT defines how the container starts

Step 3: Build Docker Image

docker build -t myk8sapp:latest .

Code Explanation

  • docker build creates an image from the Dockerfile

  • -t myk8sapp:latest assigns a name and tag

  • . specifies the current directory as build context

Verify the image:

docker images

Code Explanation

  • Lists all locally available Docker images

  • Confirms that the image was built successfully

Step 4: Run Docker Container (Validation Step)

docker run -d -p 8080:80 myk8sapp

Code Explanation

  • -d runs the container in detached mode

  • -p 8080:80 maps host port 8080 to container port 80

  • myk8sapp is the image name

Access the application: http://localhost:8080

This step validates that the containerized application is functioning correctly.

Step 5: Push Image to Docker Hub

docker tag myk8sapp yourusername/myk8sapp
docker push yourusername/myk8sapp

Code Explanation

  • docker tag renames the image for Docker Hub

  • docker push uploads the image to a remote repository

  • Kubernetes pulls images from such repositories

Step 6: Create Kubernetes Deployment Configuration

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myk8sapp-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: myk8sapp
  template:
    metadata:
      labels:
        app: myk8sapp
    spec:
      containers:
      - name: myk8sapp
        image: yourusername/myk8sapp
        ports:
        - containerPort: 80

Code Explanation

  • kind: Deployment defines a deployment resource

  • replicas: 2 ensures two instances of the application

  • matchLabels connects deployment with pods

  • containers defines container configuration

  • image specifies which Docker image to use

Step 7: Create Kubernetes Service Configuration

apiVersion: v1
kind: Service
metadata:
  name: myk8sapp-service
spec:
  type: NodePort
  selector:
    app: myk8sapp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
    nodePort: 30007

Code Explanation

  • kind: Service exposes the application

  • type: NodePort allows external access

  • selector connects service to pods

  • nodePort defines the external access port

Step 8: Deploy to Kubernetes Cluster

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Code Explanation

  • kubectl apply creates resources in the cluster

  • -f specifies the configuration file

Step 9: Verify Deployment

kubectl get pods
kubectl get services

Code Explanation

  • get pods shows running containers

  • get services shows exposed endpoints

Step 10: Access the Application

minikube service myk8sapp-service

Code Explanation

  • Opens the application in a browser using Minikube

  • Automatically resolves service URL

Alternatively:

http://:30007

Benefits of Using Kubernetes with ASP.NET Core

Scalability

Kubernetes automatically scales applications based on traffic.

High Availability

Multiple replicas ensure the application remains available.

Self-Healing

Failed containers are automatically restarted.

Load Balancing

Traffic is distributed across multiple instances.

Best Practices for Production Deployment

  • Use environment-specific configurations

  • Implement health checks (liveness and readiness probes)

  • Define CPU and memory limits

  • Use logging and monitoring tools

  • Avoid using latest tag in production images

Common Mistakes to Avoid

  • Skipping container validation before deployment

  • Incorrect port configurations

  • Not versioning Docker images

  • Ignoring resource constraints

Summary

Deploying an ASP.NET Core application using Kubernetes provides a robust and scalable solution for modern application hosting. By containerizing the application with Docker and orchestrating it using Kubernetes, developers can achieve high availability, fault tolerance, and seamless scalability. This approach aligns with cloud-native development practices and is essential for building production-ready .NET applications.

Membership not found