9

We're creating APIs using ServiceStack that are multi-tenant. We want to do DNS-based load-balancing and routing, rather than stitch things up via a reverse proxy (like nginx or haproxy).

We have Request DTOs that have a Tenant parameter. ServiceStack (and its SwaggerFeature) allow us to define custom routes, and document the DTOs such that we can read values from path, query, headers, or body.

How do we (best) wire things so that DTO properties can read values from a hostname pattern as well? So, make the Route take values from matching out of the hostname as well as the path?

We'd like to have URLs like

  • https://{tenant}.{DNS zone for environment}/{rest of path with tokens}

Also - out DNS zone will vary depending which environment we're in - for non-production we use (say) testing-foobar.com, and production we use real-live.com. Ideally we'd be able to support both with a single route declaration (and we prefer decorating the Request DTO instead of imperative declaration at run-time AppHost.Init).

Peter Mounce
  • 4,105
  • 3
  • 34
  • 65
  • 1
    My first inclination is to use [request and response filters](https://github.com/ServiceStack/ServiceStack/wiki/Request-and-response-filters) Have you considered them? – Pauli Price Sep 03 '13 at 15:20
  • 4
    I'd use a Request filters injecting any Request DTO that implements a custom `ITenant` interface that just has a `Tenant` property. Another solution is to use a `IHttpRequest.Tennant()` extension method that you can re-use inside all services which inspects the AbsoluteUri or RawUrl properties. – mythz Sep 03 '13 at 15:51
  • @mythz - is there an example somewhere showcasing how to implement this in ServiceStack? – Marek Oct 23 '13 at 13:56

1 Answers1

3

I solved this just this week, on a existing multi-tenant system which uses .NET security principals to deal with the user permissions and tenants. I used a custom ServiceRunner to select the tenant and set up the security. Your approach to multi-tenant is different, but using a ServiceRunner still seems a valid approach.

You'd end up with something like this:

public class MyServiceRunner<T> : ServiceRunner<T>
{
    public MyServiceRunner(IAppHost appHost, ActionContext actionContext)
        : base(appHost, actionContext)
    {}

    public override void BeforeEachRequest(IRequestContext requestContext, T request)
    {
        // Set backend authentication before the requests are processed.
        if(request instanceof ITenantRequest)
        {
            Uri uri = new Uri(requestContext.AbsoluteUri);
            string tenant = uri.Host; // Or whatever logic you need...
            ((ITenantRequest).Tenant = tenant;
        }
    }
}

public class MyAppHost : AppHostBase
{
    public MyAppHost() : base("My Web Services", typeof(MyService).Assembly) { }

    public override IServiceRunner<TRequest> CreateServiceRunner<TRequest>(ActionContext actionContext)
    {
        return new MyServiceRunner<TRequest>(this, actionContext);
    }

    public override void Configure(Container container)
    {
        ...
    }
}

Perhaps the Requests filtering approach is somehow better, but this does the job for us.

Mike Mertsock
  • 11,825
  • 7
  • 42
  • 75
AVee
  • 3,348
  • 17
  • 17