Building Multitenant Architecture Using ASP.NET Core And Micro Services

Introduction 

Web applications are shifting toward cloud infrastructure and microservices, to achieve high availability and extensibility.

Instead of deploying an application per client, organizations prefer multitenancy to save infrastructure cost and deployment time. Multitenant architecture helps to adopt changes for different clients under the hood. In this article, I am not going to discuss database design for multitenant applications but I will be focused on achieving separation for different clients.

In this article, I will explain how we can build a multitenant system using asp.net core and autofac.

A multitenant syetsm

 

 

 

 

How to achieve multitenancy

In multitenant architecture, the very first step is to identify tenant. In real infrastructure we have multiple ways to identify tenants; e.g., from subdomain name tenant1.xyz.com, tenant2.xyz.com. Since there are many ways to identify tenant and resolve all the dependencies for specific tenants, I am going to use autofac multitenant(DI framework) which has a great support for multitenancy.

In this application I am using url segment as {tenant}/Home/Index to identify tenant. I will use custom implementation of ITenantIdentificationStrategy to retrieve tenant id to identify tenant from url as follows.

public class TenantResolverStrategy: ITenantIdentificationStrategy {
    private IHttpContextAccessor _httpContextAccessor;
    public TenantResolverStrategy(IHttpContextAccessor httpContextAccessor) {
        _httpContextAccessor = httpContextAccessor;
    }
    public bool TryIdentifyTenant(out object tenantId) {
        tenantId = null;
        try {
            var context = _httpContextAccessor.HttpContext;
            if (context != null && context.Request != null) {
                // get very first segment
                var uriSeg = context.Request.Path.Value.Split('/');
                tenantId = uriSeg[1];
            }
        } catch (Exception) {}
        return (tenantId != null || tenantId == (object)
            "");
    }
}

Our next step will be to add default (common) implementation for tenants. In multitenant system most of the clients(tenants) will be using common behaviour but many of them will ask for the different behaviour and business rules as per their business model.

In order to consider both, we must have two implementations as follows,

1. Default implementation : common implementation.
2. Custom implementation : custom implementation.

Now we will create three different loosely coupled services (microservices) for above architecture as follows,

1. DefaultService : it will have basic implementation for getting user data.
2. Tenant1Service : it will have custom implementation for tenant1.
3. Tenant2Service : it will have custom implementation for tenant2.

I am using a proxy implementation for each service and using the same for the different tenant. If there is no service registered for current tenant or user, the default implementation will work. The purpose of separate service is scalability.

We use Multitenant container to register tenant-wise service dependency as follows,

var mtc = new MultitenantContainer(appContainer.Resolve < ITenantIdentificationStrategy > (), appContainer);
// Configure the overrides for each tenant by passing in the tenant ID
mtc.ConfigureTenant("tenant1", b => {
    b.RegisterType < Tenant1ServiceProxy > ().As < IServiceProxy > ().InstancePerDependency();
});
mtc.ConfigureTenant("tenant2", b => {
    b.RegisterType < Tenant2ServiceProxy > ().As < IServiceProxy > ().InstancePerDependency();
});

Once we have done this, we can resolve serivces as usual,

public HomeController(IServiceProxy service){ }

and tenant related tasks will be managed by autofc framework.

Using different controller for tenant

In this sample project (github link), I am having different projects(service and controllers) for tenants(default, tenant1,tenant2).

Using IServiceProxy interface
public interface IServiceProxy {
    IList < UserModel > GetAll();
}

I have different implementation for default, tenant1 and tenant2, which are having a simple http call to access data fom respective services.

Now as you can see we can have different implementation of services as per tenant. But still, the challenge is to have the same controller.

What if we need a set of different actions for a particular tenant?

Since Mvc framework registers all the contollers and from the referenced assembly or from the same assembly, while calling controller action it looks up for all the controllers according to route parameters.

In order to invoke an appropriate action for current tenant, I am overriding SelectBestAction method of ActionSelecor class which will returns controllers for tenant in our case. It provides full qualified named of controller classes but for simplicity, I m looking for the name which has tenant name in it.

public class TenantActionSelector: ActionSelector {
    private ITenantIdentificationStrategy _tenantIdentificationStrategy;
    public TenantActionSelector(IActionDescriptorCollectionProvider actionDescriptorCollectionProvider, ActionConstraintCache actionConstraintCache, ILoggerFactory loggerFactory, ITenantIdentificationStrategy tenantIdentificationStrategy): base(actionDescriptorCollectionProvider, actionConstraintCache, loggerFactory) {
        _tenantIdentificationStrategy = tenantIdentificationStrategy;
    }
    protected override IReadOnlyList < ActionDescriptor > SelectBestActions(IReadOnlyList < ActionDescriptor > actions) {
        List < ActionDescriptor > result = null;
        var tid = GetTenantId();
        // find controller dependency for current tenant
        if (tid != null && (string) tid != "") {
            // here we will have full assembly name
            var tenantController = string.Format("{0}controllers", (string) tid).ToLower();
            result = actions.Where(x => x.DisplayName.ToLower().Contains(tenantController)).ToList();
        }
        // add default if not found
        if (result == null || result.Count() == 0) {
            result = actions.Where(x => x.DisplayName.ToLower().Contains("defaultcontrollers")).ToList();
        }
        return result;
    }
    protected object GetTenantId() {
        var tenantId = (object) null;
        var success = _tenantIdentificationStrategy.TryIdentifyTenant(out tenantId);
        if (!success || tenantId == null) {
            return "";
        }
        return tenantId;
    }
}

Lets visualise it ,

 

Now we are done.

I am not good at design :(. So I am using a simple table template for demonstration.

Default Tenant(default service, default controller)



Tenant 1 (has seperate service and controller with additional action method)



Tenant 2 (Default controller , seperate service)


Note

This is a sample project, to get started with multitenancy, and I have not covered all the parts such as authentication and security. However, you can achieve it by exploring the autofac and aspnet core docs.

You can explore source code to play with and customize the same as per your requirements. For this sample project, you will have to run multiple projects together (all services along with the main app).

Github link

https://github.com/Anupam-/AspNetCoreMultitenantMicroservicesArchitecture

Kindly share your suggestions and feedback. Thanks :).