Hosting the most popular ASP.NET Core CMS, Orchard Core at UpCloud

It’s no surprise that you can host ASP.NET Core apps at UpCloud, but let’s see a concrete example: how would you host an app using the open-source CMS Orchard Core?

Orchard Core?

If you’re a .NET web developer, you most possibly do your work built on ASP.NET Core. And if you do that, it’s useful to go one step further so you don’t have to reinvent the wheel for each project, and use Orchard Core too.

Orchard extends ASP.NET Core with developer-level features (like data access, localization, logging, multi-tenancy…) and user facing ones, centered mostly around content management (content/user/media management, workflows, audit trail…). This provides a good foundation to build your app on, because you get all the basic stuff for free. While Orchard Core is much more than a CMS, if we look at it in this way, it’s actually the most popular open-source .NET one! If you count GitHub stars, that is. Cherry picking data is fun! (But according to open-source activity metrics, it’s always among the top .NET projects altogether.)

If you’d like to know more about Orchard Core, check out its website, and especially its documentation. The rest of this guide assumes that you have a basic understanding of Orchard Core.

Let’s host Orchard Core!

Being close to the Microsoft ecosystem, Orchard Core has built-in support for a lot of Azure services, including Media storage, secret storage, e-mail delivery and sending SMS, AI search, and even observability with Azure Application Insights with the community Lombiq module. AWS also has support for Media storage. For cloud-hosted full-text search we can use Elasticsearch, and Redis to aid with horizontal scaling. How does using UpCloud, without specific support from Orchard Core, compare?

We’ve looked into hosting a vanilla Orchard Core app as a proof of concept, and are sharing our experiences here. The goal was to run Orchard Core with a minimal hosting environment, but with a stateless web server (so, keeping the database and Media storage separate). This could’ve been simplified to only use a web server (and keep the database in a local SQLite file, as well as use local Media files), but we wanted to go a bit more realistic than that. To be able to play around with the web server from the GUI too, we’ve chosen Windows as the OS if available. Additionally, we also checked if the platform helps with any of the other common infrastructure requirements, like sending e-mails or observability.

What does UpCloud provide for Orchard Core hosting?

As far as services interesting for Orchard Core hosting UpCloud offers VMs with load balancing, AWS S3-compatible object storage, and databases as a service. Managed Kubernetes is also available, but for the sake of this post, trying to host a simple app, we won’t create a cluster. Instead of Redis, you can create Valkey instances (Valkey is an open-source fork of Redis), which, for now, should just work with Orchard Core’s Redis support. While OpenSearch is also available, that’s incompatible with Orchard’s Elasticsearch integration.

If you want to send e-mails, implement observability, or add search and indexing other than with Lucene on the web server, you’re on your own.

Creating an Orchard Core hosting environment

You surely already guessed, but we’ll need three UpCloud services:

• A server, i.e. a VM.
• A managed database; we’ll use PostgreSQL.
• Object Storage for Media.

Let’s start with the server! What’s important here is that having all three resources in the same datacenter is kind of important for low latency, so be sure to use the same location at the later steps too. For now, let’s opt the smallest suitable plan, the 1-CPU one with 2 GB of RAM:

The server takes a few minutes to get provisioned, so in the meantime, we can create an Object Storage instance (public connection is only enabled for any necessary troubleshooting later):

And a single-node Postgres database server:

Note that this runs on its own VM.

This is everything we need, so now we can continue with setting up Orchard Core in this environment.

Deploying Orchard Core to the web server

You can deploy an ASP.NET Core app, including an Orchard Core-using one, with Web Deploy to IIS, using automated deployment from a GitHub Actions workflow, or just by copying its publish outputs to the server. Here, we opted with the simplest option: we published the web app to a folder from Visual Studio (but running `dotnet publish` from the CLI would be equally suitable), and copied the resulting files to the server via Remote Desktop. Then we could simply run the web app:

The app listens to port 80 because we added an _appsettings.Production.json_ file configuring it:

{
  "Kestrel": {
    "Endpoints": {
      "HttpEndpoint": {
        "Url": "http://*:80"
      }
    }
  }
}

This allows you to simply open the IP of the server in a browser, or point a DNS A record to it. Our site is now available on the internet! …after we allowed the exe of our web app through the Windows Firewall, that is.

You may notice that this is a really barebones approach: There’s no IIS, no HTTPS, no proper deployment. And you’re right! This is a focused example of getting Orchard Core running, but we’ll return to the missing pieces later.

Setting up Orchard Core

Running the Orchard Core setup is standard: Just fill out the usual settings on the setup screen, and point the app to the Postgres DB. For the latter, you can copy the Postgres connection string from the UpCloud Control Panel, and ask your favorite AI tool to turn it into an Npgsql connection string that .NET uses.

Once setup finishes, you can configure Media storage too. First, you’ll need to create a storage user for the app; I suggest attaching the ECSS3FullAccess policy, since that’s the only one that seems to allow read-write access. Also, be sure to create a bucket for Media files; here we named it just “media”.

Now it’s time to configure the connection for the app. Again, you can use the _appsettings.Production.json_ file to add something like below, resulting in the following full file:

{
  "Kestrel": {
    "Endpoints": {
      "HttpEndpoint": {
        "Url": "http://*:80"
      }
    }
  },
  "OrchardCore": {
    "OrchardCore_Media_AmazonS3": {
      "ServiceURL": "https://vrbd8.upcloudobjects.com",
      "Credentials": {
        "SecretKey": "add the secret of the user you created",
        "AccessKey": "add the access key of the user you created"
      },
      "CreateBucket": true,
      "RemoveBucket": true,
      "BucketName": "media"
    }
  }
}

Be sure to change the `ServiceURL` value to that of your instance, as indicated on its Overview page (under “S3 endpoint”). That’s actually an undocumented configuration key that comes very handy when, as we do here, you connect to an S3 account outside of AWS.

Now restart the app (so it reads the updated configuration file) and enable the Amazon Media Storage feature from the Orchard Core admin. It’ll work, despite it not running in Amazon. Magic!

And with this, our app fully works!

Why would you (not) use UpCloud?

OK, so we’ve seen that running Orchard Core under UpCloud works. This is not a huge surprise, but it’s nice to get it verified and have the basics figured out. Why would we do this, though, instead of choosing the beaten path with Azure or AWS, for example?

1. European: UpCloud is not just hosting in Europe, and specifically, the EU, but the company itself is also based in an EU country, under strict EU privacy regulations. If that matters for you, either for sentimental reasons or as a matter of company policy, it can be a big plus.

2. Costs: UpCloud can be a lot cheaper. At €23/month, the UpCloud server provides roughly the same as an A1\_v2 Azure VM, which costs €45/month. However, the managed Postgres instance at €30/month and the storage at €5/month (in total €58/month) are way above what we’d use on Azure for an entry-level app, where an S0 Azure SQL DB would be around €13/month, and storage only cents (depending on usage), altogether about €58/month too. We do get more with UpCloud (a dedicated VM for the DB and 250 GB of storage, and I think the VM is faster too), a lot more room to grow, but the cost advantage, in itself, disappears, at least in the beginning. All this being said, at Azure, we’d rather use App Services: This is a higher-level “websites as a service”, offering a bunch of convenience features like automated deployment, staged publishing, and configuration management. The smallest proper App Services-based infrastructure (with a staging slot and separate staging and production DBs) comes at around €90/month, though, but that also contains a lot of features lacking from VMs.

3. Simplicity: Without consulting any resource, just by playing with the Control Panel, I could fully understand the UpCloud offering (I think…) within like half an hour. Getting the full Orchard Core environment running wouldn’t have been much more, had I not written this post at the same time.

4. You matter and can talk to actual people: I had some question about setting up the storage, so I opened the chat window and had a real person from UpCloud answer within less than 5 minutes. The larger the cloud company, the larger of a client you have to be to matter to them; that translates to support request forms with dozens of fields, days to wait for a solution, and even having to subscribe to a paid support plan. As an SME it’s much easier to work with a provider that’s also an SME, instead of a huge multinational enterprise.

Coming from frequently using the cushy but extremely complex ecosystem of Azure, using a provider like UpCloud is certainly an interesting change. It seems to me that ultimately, there’s a lot of work to do if you want to have a full-blown, highly automated hosting environment for Orchard Core, with an option for horizontal scaling. Below are the features that I’d consider necessary, and while these are given with Azure, you need to roll your own solutions with UpCloud:

• Staged publishing (blue-green deployment): You’d need to set up multiple VMs or multiple sites, and manage swapping staging with production somehow on your own.
• Automated deployments: I think under a Windows server, the easiest would be to set up Web Deploy and use it from an automation platform like GitHub Actions.
• Observability: You’d either need to host an observability platform yourself, or use an external service.
• The lack of a search/indexing service is less of an issue, because you can just use the Elastic Cloud (what’s the option in Azure and AWS too), and I’d consider the lack of an e-mail service not a huge issue either (you can just use something like SendGrid). Managed Valkey is good, but starting at €50/month, it’s not priced for an easy entry (just as Postgres), although it also provides a lot more resources than the lowest tiers of Azure Cache for Redis do (for a lower price).

Yes, you could build an all-in-one infrastructure with Kubernetes, and have containers with services for all the above features (and a DB and storage as well), but that’s a large complexity you need to manage. Using Terraform, supported by UpCloud, to ramp up your infrastructure can cut down on manual repetition (and aid portability to other providers to an extent), but is also work that you have to invest. And at the entry level, managed solutions for services like SQL and Redis (instead of hosting your own VMs/containers) can be more cost-efficient too (but that flips if your app’s demand increases).

So, what should I do?

To me, the points mentioned above seem to be areas to improve. However, I can understand if the UpCloud team wants to focus on the core offering instead of becoming an everything cloud. Perhaps having a marketplace that easily lets you integrate external services to plug the holes would then be a good idea?

Until then, UpCloud can be a good choice to host your Orchard Core app if you don’t need anything beyond what’s easily possible with the existing offering, or if you already invested into a portable Kubernetes-based infrastructure.

Do you need help hosting Orchard Core at UpCloud or even onboard of a satellite (not kidding)? You should ask Lombiq, one of the biggest Orchard Core teams out there!