Multi-Region ASP.NET Core Session Provider for NCache

NCache provides session sharing support across multiple regions. This prevents users from losing their sessions in case you need to reroute your traffic to another location because of traffic or due to disaster recovery. Sessions are replicated across WAN seamlessly without replicating the entire session which may result in bandwidth expense. Figure 1 shows the process flow associated with session sharing across multiple regions.

Figure 1: Session Sharing across Data Centers

To share sessions across regions, you need to enable location affinity. This is enabled by setting the EnableLocationAffinity flag to true and providing the cache names and prefixes to identify the source (location) of the cache for the request. You can provide multiple cache names which form the web farm, however the cache specified against CacheName is considered the primary cache by default.

Install NuGet Package

Install the NuGet package Alachisoft.NCacheSessionServices.Enterprise to your application by executing the following command in the Package Manager Console:

Install-Package Alachisoft.NCacheSessionServices.Enterprise

Include Namespaces

To utilize the APIs, include the following namespaces in your application in Startup.cs of your application:

• using Alachisoft.NCache.Web.SessionState;
• using Microsoft.AspNetCore.Hosting;

ASP.NET Core Sessions can be shared across data centers using NCache in two steps:

• Configuring the session management service

• Adding middleware to the application

Step 1: Configure Services

The session management service needs to be initialized. In Startup.cs, use the SetNCacheSessionConfiguration() extension method on IServiceCollection in ConfigureServices() to initialize the service. The very basic overload of this extension method takes an IOptions<NCacheSessionConfiguration> as its base configuration.

There are two methods to specify configurations:

1. Through your application as IOptions or

2. In JSON format in Appsettings.jsonof your application.

Method 1: Specifying Configurations in IOptions

To enable session sharing, it is required to set the EnableLocationAffinity flag to true and provide the list of caches in AffinityMapping. Note that one of the caches should match the CacheName, which is considered the primary cache.

public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddMvc();

    services.AddNCacheSession(configuration =>
    {
        configuration.CacheName = "LondonCache"; //compulsory
        configuration.EnableLogs = true;
        configuration.SessionOptions.IdleTimeout = 5;
        configuration.EnableLocationAffinity = true;
        configuration.AffinityMapping = new acheAffinity[]
        {
            new CacheAffinity { CacheName = "LondonCache", CachePrefix = "LDC"},
            new CacheAffinity { CacheName = "NewYorkCache", CachePrefix = "NYC"},
            new CacheAffinity { CacheName = "TokyoCache", CachePrefix = "TKC"},
        };
    });
}

Method 2: Specifying Configurations in Appsettings.json

You can either specify the configurations within your application through IOptions or in JSON format in Appsettings.json of your application. This JSON section can then be referred to in the SetNCacheSessionConfiguration() method provided by NCache.

"NCacheSettings": {
    "EnableLocationAffinity": true,
    "EnableLogs": true,
    "RequestTimeout": 5,
    "CacheName": "LondonCache",
    "AffinityMapping": [
      {
        "CacheName": "LondonCache",
        "CachePrefix": "LDC"
      },
      {
        "CacheName": "NewYorkCache",
        "CachePrefix": "NYC"
      },
      {
        "CacheName": "TokyoCache",
        "CachePrefix": "TKC"
      }
    ]
}

public void ConfigureServices(IServiceCollection services)
{
    //Add framework services
    services.AddMvc();

    //Add services to the container                    
    services.SetNCacheSessionConfiguration(Configuration.GetSection("NCacheSettings"));

    services.AddNCacheSession();
}

Step 2: Add Middleware to Application

Once the services have been initialized, you can now configure the HTTP request pipeline by adding middleware in the Configure() method. The following is an excerpt showing the addition of a middleware layer through the use of UseNCacheSession() extension method in IApplicationBuilder. The NCache session middleware should always be stacked before the layer that utilizes the sessions.

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    loggerFactory.AddConsole(Configuration.GetSection("Logging"));
    loggerFactory.AddDebug();

    if (env.IsDevelopment()){
        app.UseDeveloperExceptionPage();
        app.UseBrowserLink();
    }
    else{
        app.UseExceptionHandler("/Home/Error");
    }
    app.UseStaticFiles();           
    app.UseNCacheSession(); //store NCache session data            
    app.UseMvc(routes =>
    {
        routes.MapRoute(
            name: "default",
            template: "{controller=myApp}/{action=Index}/{id?}");
    });
}