One of our goals here on the Google Cloud Platform team is to support the broadest possible array of platforms and operating systems. That’s why we’re so excited about the ASP.NET Core, the next generation of the open source ASP.NET web framework built on .NET Core. With it, .NET developers can run their apps cross-platform on Windows, Mac and Linux.
One thing that ASP.NET Core does is allow .NET applications to run in Docker containers. All of a sudden, we’ve gone from Windows-only web apps to lean cross-platform web apps running in containers. This has been great to see!
|ASP.NET Core supports running apps across a variety of operating system platforms|
That’s where the open-source Kubernetes platform comes in. Kubernetes provides high-level building blocks such as pods, labels, controllers and services that collectively help maintenance of containerized apps. Google Container Engine provides a hosted version of Kubernetes which can greatly simplify creating and managing Kubernetes clusters.
My colleague Ivan Naranjo recently published a blog post that shows you how to take an ASP.NET Core app, containerize it with Docker and and run it on Google App Engine. In this post, we’ll take a containerized ASP.NET Core app and manage it with Kubernetes and Google Container Engine. You'll be surprised how easy it is, especially considering that running an ASP.NET app on a non-Windows platform was unthinkable until recently.
PrerequisitesI am assuming a Windows development environment, but the instructions are similar on Mac or Linux.
First, we need to install .NET core, install Docker and install Google Cloud SDK for Windows. Then, we need to create a Google Cloud Platform project. We'll use this project later on to host our Kubernetes cluster on Container Engine.
Create a HelloWorld ASP.NET Core app.NET Core comes with .NET Core Command Line Tools, which makes it really easy to create apps from command line. Let’s create a HelloWorld folder and create a web app using dotnet command:
$ mkdir HelloWorld $ cd HelloWorld $ dotnet new -t web
Restore the dependencies and run the app locally:
$ dotnet restore $ dotnet run
You can then visit http://localhost:5000 to see the default ASP.NET Core page.
Containerize the ASP.NET Core app with DockerLet’s now take our HelloWorld app and containerize it with Docker. Create a Dockerfile in the root of our app folder:
FROM microsoft/dotnet:1.0.1-core COPY . /app WORKDIR /app RUN [“dotnet”, “restore”] RUN [“dotnet”, “build”] EXPOSE 8080/tcp ENV ASPNETCORE_URLS http://*:8080 ENTRYPOINT [“dotnet”, “run”]
This is the recipe for the Docker image that we'll create shortly. In a nutshell, we're creating an image based on microsoft/dotnet:latest image, copying the current directory to /app directory in the container, executing the commands needed to get the app running, making sure port 8080 is exposed and that ASP.NET Core is using that port.
Now we’re ready to build our Docker image and tag it with our Google Cloud project id:
$ docker build -t gcr.io/<PROJECT_ID>/hello-dotnet:v1 .
To make sure that our image is good, let’s run it locally in Docker:
$ docker run -d -p 8080:8080 -t gcr.io/<PROJECT_ID>/hello-dotnet:v1
When you visit http://localhost:8080 to see the same default ASP.NET Core page, this time, it's running inside a Docker container.
Create a Kubernetes cluster in Container Engine
$ gcloud docker push gcr.io/
Create a Kubernetes cluster with two nodes in Container Engine:
$ gcloud container clusters create hello-dotnet-cluster --num-nodes 2 --machine-type n1-standard-1
This will take a little while but when the cluster's ready, you should see something like this:
Creating cluster hello-dotnet-cluster...done.
Deploy and run the app in Container Engine
$ gcloud components install kubectl
Configure kubectl command line access to the cluster with the following:
$ gcloud container clusters get-credentials hello-dotnet-cluster \ --zone europe-west1-b --project<PROJECT_ID>
Finally, create a deployment from our image in Kubernetes:
$ kubectl run hello-dotnet --image=gcr.io/
hello-dotnet:v1 \ --port=8080 deployment “hello-dotnet” created
Make sure the deployment and pod are running:
$ kubectl get deployments NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE hello-dotnet 1 1 1 0 28s $ kubectl get pods NAME READY STATUS RESTARTS AGE hello-dotnet-3797665162-gu99e 1/1 Running 0 1m
And expose our deployment to the outside world:
$ kubectl expose deployment hello-dotnet --type="LoadBalancer" service "hello-dotnet" exposed
Once the service is ready, we can see the external IP address:
$ kubectl get services NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-dotnet XX.X.XXX.XXX XXX.XXX.XX.XXX 8080/TCP 1m
Finally, if you visit the external IP address on port 8080, you should see the default ASP.NET Core app managed by Kubernetes!
It’s fantastic to see the ASP.NET and Linux worlds are coming together. With Kubernetes, ASP.NET Core apps can benefit from automated deployments, scaling, reliable upgrades and much more. It’s a great time to be a .NET developer, for sure!