A Simple Guide to Kubernetes in C#: Building, Deploying, and Managing Your Application

Kubernetes for C# Developers, Step by Step

Kubernetes (K8s) is a powerful tool for automating the deployment, scaling, and management of containerized applications. If you’re a C# developer looking to understand how Kubernetes fits into your development workflow, this guide provides a simple, end-to-end walkthrough.

What is Kubernetes?

Kubernetes is an open-source container orchestration platform that manages your application’s deployment and scaling. Think of it as a manager for your application containers (like Docker containers):

• It ensures your app is running.
• It handles scaling based on demand.
• It replaces failed containers automatically.

📌Explore more at: https://dotnet-fullstack-dev.blogspot.com/
🌟 Clapping would be appreciated! 🚀

Why Kubernetes for C# Developers?

When you’re developing C# applications, deploying them in the cloud often means working with containers. Kubernetes simplifies this by:

• Allowing you to scale services automatically.
• Enabling zero-downtime deployments.
• Managing configurations and secrets.

Prerequisites

1. Docker Installed: Ensure Docker is installed and running.
2. Kubernetes Cluster: Use a local cluster like Minikube, Docker Desktop’s Kubernetes, or a cloud-hosted solution (e.g., Azure AKS).
3. kubectl: Install Kubernetes CLI to interact with the cluster.
4. C# Application: A simple .NET Core application to containerize and deploy.

Step 1: Create a C# Application

Create a New .NET Core Web API

dotnet new webapi -n K8sExampleApp
cd K8sExampleApp

This command creates a simple Web API project.

Test Your Application Locally

Run the application:

dotnet run

Navigate to http://localhost:5000. You should see the API response.

Step 2: Dockerize the Application

Add a Dockerfile

Create a file named Dockerfile in the root of your project with the following content:

# Base image
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80

# Build image
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["K8sExampleApp.csproj", "./"]
RUN dotnet restore "K8sExampleApp.csproj"
COPY . .
RUN dotnet publish "K8sExampleApp.csproj" -c Release -o /app/publish

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

Build and Test the Docker Image

Build the image:

docker build -t k8s-example-app .

Run the container:

docker run -p 8080:80 k8s-example-app

Test it: Navigate to http://localhost:8080 to ensure the app works in a container.

Step 3: Set Up Kubernetes Deployment

Create Kubernetes Manifests

Deployment YAML (deployment.yaml)

This file defines how your app will run in Kubernetes.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: k8s-example-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: k8s-example-app
  template:
    metadata:
      labels:
        app: k8s-example-app
    spec:
      containers:
      - name: k8s-example-app
        image: k8s-example-app:latest
        ports:
        - containerPort: 80

Service YAML (service.yaml)

This file exposes your app to the outside world.

apiVersion: v1
kind: Service
metadata:
  name: k8s-example-app-service
spec:
  selector:
    app: k8s-example-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

Apply Kubernetes Manifests

Start Minikube (if using Minikube):

minikube start

Deploy the App:

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

Check Deployment Status:

kubectl get pods
kubectl get services

Access Your App

If using Minikube:

minikube service k8s-example-app-service

If using a cloud-hosted Kubernetes:

• Note the external IP address from kubectl get services.
• Access your app at http://<EXTERNAL-IP>.

Step 4: Scale the Application

To scale your app horizontally, increase the number of replicas:

kubectl scale deployment k8s-example-app --replicas=5

Verify the new pods:

kubectl get pods

Step 5: Clean Up

When done, delete the resources to save cluster space:

kubectl delete -f deployment.yaml
kubectl delete -f service.yaml

Explaining Kubernetes to a Layman

Think of Kubernetes as a restaurant manager:

1. Containers are the chefs who cook the meals (applications).
2. The manager (Kubernetes) ensures:

• Enough chefs are working (scaling replicas).
• Any sick chef is replaced immediately (self-healing).
• Meals are served to the right customers (routing traffic).

Conclusion

Congratulations! You’ve just deployed your first C# application on Kubernetes. By containerizing the app and managing it with Kubernetes, you’ve taken a significant step toward building scalable, resilient cloud-native applications.

Next steps:

• Explore advanced features like secrets, config maps, and ingress.
• Experiment with cloud providers like Azure Kubernetes Service (AKS).

Have questions? Share them below — happy coding!