skip to content
Mohammad Rebati

Using Kubernetes & Skaffold for .NET Core APIs

/ 5 min read

Mastering Kubernetes and Skaffold for .NET Core API Development

Welcome, tech enthusiasts! If you are venturing into the vast world of Kubernetes and aiming to streamline your .NET Core API development with Skaffold, you are in for a treat. This comprehensive guide will walk you through setting up, developing, and deploying your applications with efficiency and precision. From initial setup to advanced deployment techniques, we cover it all.

Introduction to Skaffold and Kubernetes

Skaffold is a command-line tool designed to facilitate continuous development for Kubernetes applications. It automates several routine tasks such as building, pushing, and deploying applications, making it an ideal companion for any developer working in a Kubernetes environment.

Kubernetes, on the other hand, is a powerful orchestration tool for container management, scaling, and handling automated rollouts and rollbacks. It works well with Skaffold, which simplifies the continuous development cycle within Kubernetes clusters.

Setting Up Your Development Environment

Before diving into the specifics, you’ll need a working Kubernetes cluster (Minikube or a cloud-based Kubernetes service like Google Kubernetes Engine) and Skaffold installed on your development machine. Here’s a quick start on setting these up:

Installing Kubernetes

You can start a local development environment using Minikube:

Terminal window
minikube start

Certainly! Below, I’ve expanded the installation instructions for Skaffold to include details for Windows and Linux systems alongside macOS. This should provide a more comprehensive overview for users working across different operating systems.

Installing Skaffold

Skaffold can be installed on macOS, Windows, or Linux. Here are the methods for each operating system:


For macOS, you can use Homebrew to install Skaffold:

Terminal window
brew install skaffold


For Windows, Skaffold can be installed using Chocolatey:

Terminal window
choco install skaffold

Alternatively, if you prefer using Scoop, you can install it via:

Terminal window
scoop install skaffold


On Linux, you can install Skaffold by downloading the binary from the official GitHub releases page or using a package manager like apt for Debian-based distributions or yum for RPM-based distributions.

Using curl with apt:

Terminal window
sudo apt-get update && sudo apt-get install -y apt-transport-https gnupg
curl -fsSL | gpg --dearmor -o /usr/share/keyrings/skaffold-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/skaffold-archive-keyring.gpg] $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/skaffold.list
sudo apt-get update && sudo apt-get install skaffold

Using curl with yum:

Terminal window
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo
sudo yum install -y skaffold

Verifying Installation

After installation, you can verify that Skaffold is installed correctly by running:

Terminal window
skaffold version

This command will print the version of Skaffold installed on your system, confirming that the installation was successful.

Structuring Your .NET Core Projects

For a clean and manageable workspace, structure your .NET Core projects with Kubernetes in mind:


Each project should have its own k8s directory for Kubernetes manifest files. This organization aids in managing each microservice independently within the same Kubernetes cluster.

Skaffold Configuration

Centralizing Skaffold configuration allows for better management across multiple services. Place a skaffold.yaml file at the root of your solution:

apiVersion: skaffold/v2beta4
kind: Config
name: my-dotnet-solution
- image: myapi
context: MyApiProject
dockerfile: Dockerfile
- image: myanotherapi
context: MyAnotherApiProject
dockerfile: Dockerfile
- MyApiProject/k8s/*.yaml
- MyAnotherApiProject/k8s/*.yaml

This configuration specifies how Skaffold should build and deploy your .NET Core applications.

Dockerizing .NET Core APIs

Create a Dockerfile in the root of each .NET Core API project to define how your application should be containerized:

# Use the official Microsoft ASP.NET Core runtime as a parent image
FROM AS base
# Use the SDK image to build the project files
FROM AS build
COPY ["MyApiProject.csproj", ""]
RUN dotnet restore "./MyApiProject.csproj"
COPY . .
WORKDIR "/src/."
RUN dotnet build "MyApiProject.csproj" -c Release -o /app/build
# Publish the application
FROM build AS publish
RUN dotnet publish "MyApiProject.csproj" -c Release -o /app/publish
# Final stage/image
FROM base AS final
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MyApiProject.dll"]

Integrating Third-Party Services

Using external services like Redis or RabbitMQ is common in microservices architecture. Here’s how you could define these services in Kubernetes using Helm or direct Docker images:

# Redis deployment
apiVersion: apps/v1
kind: Deployment
name: redis
app: redis
replicas: 1
app: redis
app: redis
- name: redis
image: redis:latest
- containerPort: 6379
# Redis service
apiVersion: v1
kind: Service
name: redis-service
- port: 6379
app: redis

Advanced Skaffold Features

Explore advanced features such as port forwarding, file sync, and custom build scripts in Skaffold to enhance your development workflow:

- resourceType: service
resourceName: my-api-service
namespace: default
port: 80
localPort: 8080
- '**/*.cs'

Continuous Integration and Deployment

Leverage Skaffold’s pipelines for CI/CD by integrating with Jenkins, GitHub Actions, or GitLab CI. This will automate your build and deployment process upon code commit, ensuring that every merge is tested and deployed seamlessly.


Using Skaffold with Kubernetes not only simplifies your development process but also enhances the scalability and manageability of .NET Core APIs. By following this guide, you are well-equipped to leverage these powerful tools to their fullest potential, enabling faster development cycles and more reliable deployments. Embrace this workflow, and you’ll see substantial improvements in your DevOps practices. Happy coding!