A growing trend lately on the internet is the use of Headless CMS. To me, it seems like just another buzzword, but if you do any research you will find all the benefits. The main one being separating all your content from how it is displayed. Doing this allows content editors to do their job without stepping on the developer's toes. This allows the developers to work at the same time the editors eliminated the bottleneck of one waiting for the other. One of the more polished Headless CMS vendors out there is Kentico Cloud. I may be a little biased, but I was blown away by how easy it is to get up and running, and to top it off their starter plan is free so you can get your feet wet and play with the great feature set. 

This tutorial will guide you in creating a foundation to get you started with a Kentico Cloud powered application. I am choosing to use .NET MVC Core2.2 but there are several other platforms available. And of course, content coming from Kentico Cloud. In this tutorial, I’ll be using the sample site that is available so all the content is already there. 

Ubuntu Server 18.04 LTS

.NET MVC Core2 is cross-platform which allows for many possible choices for a server platform. Since I’m a supporter of open source software my choice is Ubuntu Server 18.04 LTS (long term support). You also get a 10-year lifecycle which means you’ll continue to get security updates for that timeframe. 

Kestrel, What Is It?

ASP.Net MVC Core2 relies on the Kestrel web server to handle the requests to your application and is installed by default. Kestrel is an open source cross-platform web server. Even through Kestrel can serve web pages just like IIS you will need to use a reverse proxy to server pages to those other than localhost. Kestrel is really just a command line application designed for speed. Because of its lightweight design it is missing security, compression, and caching, something a full fledged web server should have. Again, this makes it FAST.

Introducing nginx

For the reverse proxy, nginx (pronounced engine-x) fits the bill. Nginx sits between Kestrel and the internet. It handles all the stuff that Kestrel wasn’t designed to do by sanitizing and passing the requests on. It is also super fast and able to handle a high volume of traffic with a small memory footprint. Once again nginx is open source so there are no licensing fees required. 

Let's get started

Server Install using Vultr

Vultr is a high-performance cloud host that I’ve used for several years and they make server installs super easy. You can have a VM up and running in the time it takes to brew a pot of coffee. They’re also pretty inexpensive with plans starting at just $2.50 a month. For this tutorial, I’ve gone with their 1CPU/2GB package at only $10 a month which is more than enough for most simple sites.

Ubuntu Configuration

Once the server is all up and running we need to get it ready for MVC Core 2 app hosting. We’ll be installing the MVC Core2 runtime as well as nginx.

Add a User

We first need to add a user that will log into that is not root. Logging into root is not recommended since you can fat finger yourself to server collapse. This step is only necessary if you are using the pre-packaged Ubuntu installation provided by Vultr. The normal Ubuntu Server installation will have you do this during setup

adduser myuser 

Add user to the Sudo Group

To run elevated commands our user needs to be added to the sudo group

usermod -aG sudo myuser

Change to the New User

Let’s be safe and run as non-root

su myuser 
cd

Add an Application User

The application will need its own user. This is similar to the name of an app_pool in the IIS world. This allows us to set file permissions on what our MVC app has access to.

sudo adduser dancinggoat 

Add Root Directory for our Application

This is where our app will reside. Most tutorials will have you put it in /var/www which is great if it’s the only site on the web server. I like to put my sites in the home directory of the user that’s running it.

sudo mkdir /home/dancinggoat/dancinggoat.com 

Change Permissions

We need to make sure our app user can access the directory.

sudo chown dancinggoat:dancinggoat /home/dancinggoat/dancinggoat.com 

Disable Root SSH Login

Let’s disable the root user so there are no mistakes. Be sure you can successfully log into the user account we created at the beginning. By default, sshd does not allow root ssh so all we need to do is comment the line out.

sudo vim /etc/ssh/sshd_config

#comment out the line
#PermitRootLogin yes

sudo service sshd restart

Install .Net Core Runtime

To install the ASP.Net MVC Core2 runtime we need to add the Microsoft apt package repository, be sure to update the available package list and install the runtime.

https://dotnet.microsoft.com/download/linux-package-manager/ubuntu18-04/runtime-2.1.2

wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
sudo add-apt-repository universe 
sudo apt-get install apt-transport-https 
sudo apt-get update 
sudo apt-get install aspnetcore-runtime-2.2

Install Nginx

Installing nginx is pretty straight forward.

sudo apt-get install nginx

Configure Nginx

We need to create a new configuration file in the /etc/nginx/sites-available. We can use the below example to get you started. Wherever the Dancing Goat domain is, replace it with your domain. This will setup nginx to pass any requests to your domain to localhost port 5000 which is the default Kestrel listening port. Configure a reverse proxy server here.

cd /etc/nginx/sites-available
sudo vim dancinggoat.config
server {
    listen        80;
    server_name   dancinggoat.com *.dancinggoat.com;
    location / {
        proxy_pass         http://localhost:5000;
        proxy_http_version 1.1;
        proxy_set_header   Upgrade $http_upgrade;
        proxy_set_header   Connection keep-alive;
        proxy_set_header   Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header   X-Forwarded-Proto $scheme;
    }
}

Make symlink to Enable Site

To enable the sites we need to create a sym-link so nginx knows to include the site when it starts up. 

cd ../sites-enabled
sudo ln -s ../sites-available/dancinggoat.config .

Create Service for ASP.Net Core2 App

Even though you can start Kestrel from the command line, doing that in a normal server setup isn’t very practical. You’d need to manually start the app every time the server boots and also if it crashes. Since Ubuntu uses systemd to manage services we’ll need to create a new service for it to run.

sudo vim /etc/systemd/system/dancinggoat.service
[Unit]
Description=Kentico Cloud Boilerplate Example

[Service]
WorkingDirectory=/home/dancinggoat/dancinggoat.com
ExecStart=/usr/bin/dotnet /home/dancinggoat/dancinggoat.com/DancingGoat.dll
Restart=always
# Restart service after 10 seconds if the dotnet service crashes:
RestartSec=10
KillSignal=SIGINT
SyslogIdentifier=dotnet-dancinggoat
User=dancinggoat
Environment=ASPNETCORE_ENVIRONMENT=production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target

Install the Kentico Cloud MVC Core2 Boilerplate and Publish to Ubuntu

Now it’s time to jump over to a windows command line to do some local work. We’ll be adding the Kentico Cloud Boilerplate and creating our project.

mkdir C:\src\dancinggoat
cd C:\src\dancinggoat
dotnet new --install "KenticoCloud.CloudBoilerplateNet::*"
dotnet new kentico-cloud-mvc --name "DancingGoat"
cd DancingGoat
dotnet run

Update IIS Rewrite

The boilerplate contains a redirect rule that is set for example.com that we need to update using our domain.

Rename all occurrences of example.com to dancinggoat.com

cd C:\src\dancinggoat\DancingGoat
vim IISUrlRewrite.xml

Publish Boilerplate

Now we’re ready to publish our app. First, we need to create a new directory to keep our published application. Make sure the target directory is outside of your development tree or you will recursively publish the app if you go through the publish process more than once. The parameters below selects the Release configuration and set a target framework of ASP.Net MVC Core2.2

https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-publish?tabs=netcore21

mkdir ..\published
dotnet publish -c Release -f netcoreapp2.2 -o ..\published

Send Published Code to Ubuntu

Now it’s time to send the published application over to our Ubuntu VM. Since I’ve installed git integrated in the windows command line I can use scp to send that over. You could use a gui app such as FileZilla, Putty pscp or any other way to transfer the entire directory to the target.

cd ..\published
scp -r * dancinggoat@dancinggoat.com:~/dancinggoat.com/

Almost Done, Back to Ubuntu.

We’ve made it this far and we’re almost done. The last steps to go are enabling the Kestrel service and restarting nginx. 

Enable and Start the New Service

sudo systemctl enable dancinggoat.service
sudo systemctl start dancinggoat.service
sudo systemctl status dancinggoat.service

Reload nginx config

sudo service nginx reload

All Done!

Obviously, this tutorial is just to get you started but it touches a little bit of everything from hosting, developing, and publishing a completed app. If you’ve done everything properly you should be able to view the Kentico Cloud demo on the domain of your configuration.