Deploy a Containerized Asp.net Core 3.1 Web Api to Kubernetes

It's been a while since I last wrote and it's been a very interesting journey so far. Busy as usual, it's been hard to find the time to write something meaningful here. This time I'm bringing you something I've been playing with for a while and that I hope it can bring your development to another level. In this article, I will show you how easy it is to containerize your .net core applications into a Docker container and then deploy it to a Kubernetes cluster. I'm also preparing my Rpi cluster to become my main Kubernetes cluster and I will write about it once everything is up and running.

Requirements

First, you'll need the following tools and requirements (Note that I'm using Windows 10 as my main OS, so everything will be configured around it):

1) Docker Desktop for Windows:

At the time of this article, I'm using Docker 2.2.0.5 which should be the latest one. You can get the latest from here: (https://docs.docker.com/docker-for-windows/install/) and follow the steps from the website.

2) Enable Kubernetes

Once everything is installed, open Docker preferences and select Kubernetes. Enable all the options there and restart Docker. That should bring back Docker and Kubernetes and you should see them online as in the picture below:

3) Enable File Sharing

You need to make sure you enable File Sharing so the container can see your local drive.

4) Get VS Code and Install Docker plugin (v1.1.0)

I won't go into much detail about .net core installation as I'm guessing you should all be able to build and run asp.net core applications locally (https://code.visualstudio.com/Download). In this step, you'll need to download VS Code if you haven't already and the Docker plugin which will allow us to create docker files easily as they already have a pre-built template.

5) Get VS Code Kubernetes plugin (v1.2.0)

Install the plugin to generate the YAML files that will be needed to configure the cluster. This requires the YAML component and at the time of this article, I was using version 0.8.0.

6) API Testing

In order to test the API, I recommend using Swagger (https://swagger.io/tools/open-source/getting-started/) as it will easily expose the API functions and arguments that you can test. Alternatively, you can use Postman (https://www.postman.com/downloads/) which is also a great tool for this.

Dockerizing your Web API

Now we are ready to go to our Web API project and create a docker file. Note that I'm using a complex project for this exercise and not just a simple hello world. This API has additional complex requests and it also requires a Database. It also runs a few services and exposes most of the functionality via Swagger UI. 

Go to the folder of your project and type "code ." to launch vscode on the project. Then go to view -> command palette and type "docker add" as in the picture below and select "Docker Add Files to Workspace":

Once you add the template. it will ask you about the following details:

- Application platform: ASP.NET Core.

- Operating System (container): Linux

- Ports to open: 80 and 443

The example used is a bit more complex and it includes several dependencies that need to be copied across during the creation of the container. Below you can find a dependency diagram which shows the project structure:

The application consists of a WebAPI that allows you to submit trading orders and it includes a service layer that performs the triggers internally. It also connects to a SQL Server DB which sits outside the container on my local machine. So, the connection string in the project needs to point to my local machine (192.168.1.129) plus the SQL Server port (1433). Sample connection string: ("DefaultConnection": "user id=user; password=password;Initial Catalog=TradingPlatform;Data Source=192.168.1.129,1433;").

The final docker file should look as follows:

	FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS base
	WORKDIR /app
	EXPOSE 80
	EXPOSE 443
	FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS build
	WORKDIR /src
	COPY ["WebApi/*.*", "./WebApi/"]
	WORKDIR /src
	COPY ["VRTradingService/*.*", "./VRTradingService/"]
	WORKDIR /src
	COPY ["VRTradingInfraestructureServices/*.*", "./VRTradingInfraestructureServices/"]
	RUN dotnet restore "./WebApi/vr.trading.api.csproj"
	COPY . .
	WORKDIR "/src/."
	RUN dotnet build "WebApi/vr.trading.api.csproj" -c Release -o /app/build
	FROM build AS publish
	RUN dotnet publish "WebApi/vr.trading.api.csproj" -c Release -o /app/publish
	FROM base AS final
	WORKDIR /app
	COPY --from=publish /app/publish .
	ENTRYPOINT ["dotnet", "vr.trading.api.dll"]

view raw api.dockerfile hosted with ❤ by GitHub

The file mentions that it will create an asp.net core 3.1 base layer and that it will switch to the working directory app exposing ports 80 and 443. The second image includes the SDK and it will copy all our source code there. And it will run the different commands to restore the dependencies and finally to run the dotnet build command on our solution.

Now that we have our docker file, we can run it using the following commands (open a new terminal via VSCode and type "docker build -t trading-platform:v1 .". The output should look like:

	PS C:\Users\thund\Source\Repos\TradingPlatform> docker build -t trading-platform:v1 .
	Sending build context to Docker daemon 10.29MB
	Step 1/21 : FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS base
	---> 79e79777c3bf
	Step 2/21 : WORKDIR /app
	---> Using cache
	---> 362b7d6a0271
	Step 3/21 : EXPOSE 80
	---> Using cache
	---> 75b04237557e
	Step 4/21 : EXPOSE 443
	---> Using cache
	---> 51bf2ea817a2
	Step 5/21 : FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS build
	---> 4aa6a74611ff
	Step 6/21 : WORKDIR /src
	---> Using cache
	---> 4c2a5ce16109
	Step 7/21 : COPY ["WebApi/*.*", "./WebApi/"]
	---> Using cache
	---> 93b519d6d5d6
	Step 8/21 : WORKDIR /src
	---> Using cache
	---> 33f79d3a9024
	Step 9/21 : COPY ["VRTradingService/*.*", "./VRTradingService/"]
	---> Using cache
	---> 6ad96d3b012f
	Step 10/21 : WORKDIR /src
	---> Using cache
	---> e112d15992b6
	Step 11/21 : COPY ["VRTradingInfraestructureServices/*.*", "./VRTradingInfraestructureServices/"]
	---> Using cache
	---> f0f335e4ad60
	Step 12/21 : RUN dotnet restore "./WebApi/vr.trading.api.csproj"
	---> Using cache
	---> 02410fc2a067
	Step 13/21 : COPY . .
	---> Using cache
	---> 172799c888e9
	Step 14/21 : WORKDIR "/src/."
	---> Using cache
	---> 97ed8c78c312
	Step 15/21 : RUN dotnet build "WebApi/vr.trading.api.csproj" -c Release -o /app/build
	---> Running in 8eca904225f9
	Microsoft (R) Build Engine version 16.5.0+d4cbfca49 for .NET Core
	Copyright (C) Microsoft Corporation. All rights reserved.
	Restore completed in 69.52 ms for /src/WebApi/vr.trading.api.csproj.
	Restore completed in 69.09 ms for /src/VRTradingService/vr.trading.service.csproj.
	Restore completed in 1.77 ms for /src/VRTradingInfraestructureServices/vr.trading.infrastructure.services.csproj.
	vr.trading.service -> /app/build/vr.trading.service.dll
	vr.trading.infrastructure.services -> /app/build/vr.trading.infrastructure.services.dll
	vr.trading.api -> /app/build/vr.trading.api.dll
	Build succeeded.
	0 Warning(s)
	0 Error(s)
	Time Elapsed 00:00:07.52
	Removing intermediate container 8eca904225f9
	---> 555afba86b8a
	Step 16/21 : FROM build AS publish
	---> 555afba86b8a
	Step 17/21 : RUN dotnet publish "WebApi/vr.trading.api.csproj" -c Release -o /app/publish
	---> Running in 55c6e74f7371
	Microsoft (R) Build Engine version 16.5.0+d4cbfca49 for .NET Core
	Copyright (C) Microsoft Corporation. All rights reserved.
	Restore completed in 93.15 ms for /src/VRTradingInfraestructureServices/vr.trading.infrastructure.services.csproj.
	Restore completed in 93.16 ms for /src/WebApi/vr.trading.api.csproj.
	Restore completed in 1.07 ms for /src/VRTradingService/vr.trading.service.csproj.
	vr.trading.infrastructure.services -> /src/VRTradingInfraestructureServices/bin/Release/netstandard2.0/vr.trading.infrastructure.services.dll
	vr.trading.service -> /src/VRTradingService/bin/Release/netstandard2.0/vr.trading.service.dll
	vr.trading.api -> /src/WebApi/bin/Release/netcoreapp3.1/vr.trading.api.dll
	vr.trading.api -> /app/publish/
	Removing intermediate container 55c6e74f7371
	---> 4e026ebe5814
	Step 18/21 : FROM base AS final
	---> 51bf2ea817a2
	Step 19/21 : WORKDIR /app
	---> Running in b139a8c1b257
	Removing intermediate container b139a8c1b257
	---> 67f35691cc0a
	Step 20/21 : COPY --from=publish /app/publish .
	---> 7e5065016a98
	Step 21/21 : ENTRYPOINT ["dotnet", "vr.trading.api.dll"]
	---> Running in 58fbb8756b0d
	Removing intermediate container 58fbb8756b0d
	---> a9e155c4548d
	Successfully built a9e155c4548d
	Successfully tagged trading-platform:v1
	SECURITY WARNING: You are building a Docker image from Windows against a non-Windows Docker host. All files and directories added to build context will have '-rwxr-xr-x' permissions. It is recommended to double check and reset permissions for sensitive files and directories.

view raw teminal-output.ps hosted with ❤ by GitHub

If everything works as expected, the API should be in the docker container and we should be able to see that everything is running as expected (using command docker images):

	PS C:\Users\thund\Source\Repos\TradingPlatform> docker images
	REPOSITORY TAG IMAGE ID CREATED SIZE
	trading-platform v1 a9e155c4548d 11 minutes ago 214MB
	mcr.microsoft.com/dotnet/core/sdk 3.1 4aa6a74611ff 2 weeks ago 691MB
	mcr.microsoft.com/dotnet/core/aspnet 3.1 79e79777c3bf 2 weeks ago 207MB

view raw docker-images.ps hosted with ❤ by GitHub

Now we just need to run our container (docker run -it --rm -p 8080:80 trading-platform:v1) and test that everything is working correctly. Note that the exposed port is 8080.

	PS C:\Users\thund\Source\Repos\TradingPlatform> docker run -it --rm -p 8080:80 trading-platform:v1
	[11:25:29 INF] Starting...
	Hosting environment: Production
	Content root path: /app
	Now listening on: http://[::]:80
	Application started. Press Ctrl+C to shut down.

view raw running-container.ps hosted with ❤ by GitHub

As you can see in the image below, the API is up and running and I can explore it via Swagger UI on localhost:8080/swagger/api/index,html which is the port we have exposed through our container:

Deploying it to Kubernetes

Now that we have our docker container with an ASP.NET Core Web API that talks to a SQL Server DB and that will now be deployed to a Kubernetes cluster. Your Kubernetes cluster should already be up and running if you had followed the steps above during the Docker installation.

Check that your Kubernetes context is switched to docker-desktop:

You can check that the configuration is correct by using "kubectl config get-contexts":

	PS C:\Users\thund\Source\Repos\TradingPlatform> kubectl config get-contexts
	CURRENT NAME CLUSTER AUTHINFO NAMESPACE
	* docker-desktop docker-desktop docker-desktop
	docker-for-desktop docker-desktop docker-desktop
	minikube minikube minikube

view raw get-contexts.ps hosted with ❤ by GitHub

This will allow us to select the group we want to work with. Note that I have additional clusters created on my local.

Now we need to create the deployment file (deployment.yml). Generate a new deployment.yml file in your folder and then via VS Code, type "deployment" and that will bring up the inline annotation from the Kubernetes plugin. Then fill in the gaps with the information you need to set up the cluster and pods as shown in the information below:

	apiVersion: apps/v1
	kind: Deployment
	metadata:
	name: trading-platform-deployment
	spec:
	selector:
	matchLabels:
	app: trading-platform-pod
	template:
	metadata:
	labels:
	app: trading-platform-pod
	spec:
	containers:
	- name: trading-platform-container
	image: trading-platform:v1
	resources:
	limits:
	memory: "128Mi"
	cpu: "500m"
	ports:
	- containerPort: 80

view raw deployment.yml hosted with ❤ by GitHub

We will provide a deployment name "trading-platform-deployment", the name of the pod "trading-platform-pod" and the name of the docker container to use, which in our case is called "trading-platform:v1". We will then specify port 80 as the port of the container.

If everything goes well, you should see your deployment in Kubernetes ready and also the pods. We can also see that the app is running by inspecting the logs:

	PS C:\Users\thund\Source\Repos\TradingPlatform> kubectl apply -f .\deployment.yml
	deployment.apps/trading-platform-deployment created
	PS C:\Users\thund\Source\Repos\TradingPlatform> kubectl get deployments
	NAME READY UP-TO-DATE AVAILABLE AGE
	trading-platform-deployment 1/1 1 1 8m7s
	PS C:\Users\thund\Source\Repos\TradingPlatform> kubectl get pods
	NAME READY STATUS RESTARTS AGE
	trading-platform-deployment-6bf776f966-8xs7r 1/1 Running 0 10m
	PS C:\Users\thund\Source\Repos\TradingPlatform> kubectl logs trading-platform-deployment-6bf776f966-8xs7r
	[16:16:13 INF] Starting...
	Hosting environment: Production
	Content root path: /app
	Now listening on: http://[::]:80
	Application started. Press Ctrl+C to shut down.

view raw get-deployment.ps hosted with ❤ by GitHub

In order to make it publicly available, we need to provide a service layer that will give us the IP to reach the container. Now we need to generate a service.yml file (press cntrl+space to trigger the Kubernetes plugin and select the deployment service option to scaffold the service template):

	apiVersion: v1
	kind: Service
	metadata:
	name: trading-platform-service
	spec:
	selector:
	app: trading-platform-pod
	ports:
	- port: 8080
	targetPort: 80
	type: LoadBalancer

view raw service.yml hosted with ❤ by GitHub

The service is linked to the Pod and we specify the port we want to expose (8080) and the port in the container (80) and also the type of service which is LoadBalancer in our case. We can now see that everything is running correctly using the following commands:

	PS C:\Users\thund\Source\Repos\TradingPlatform> kubectl apply -f .\service.yml
	service/trading-platform-service created
	PS C:\Users\thund\Source\Repos\TradingPlatform> kubectl get services
	NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
	kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 4d10h
	trading-platform-service LoadBalancer 10.110.193.37 localhost 8080:30435/TCP 13s

view raw apply-services.ps hosted with ❤ by GitHub

And presto! Now we have our API running on a Docker Container and deployed to a Kubernetes cluster and to make it more real, the project is a complex project with services and additional libraries and also with a connection to a SQL Server DB. 

If we browse to (http://localhost:8080/swagger/api/index.html) we will be able to reach the API.

Once completed, if you want to stop the service and pod, type:

- kubectl delete service trading-platform-service

- kubectl delete pod trading-platform-deployment-6bf776f966-8xs7r