Multi-region ASP.NET Core Session Provider

NCache provides ASP.NET Core session-sharing support across multiple regions. This prevents users from losing their sessions in case they need to reroute their 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: Session Sharing across Data Centers

To share ASP.NET Core session 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 that form the web farm, however, the cache specified against CacheName is considered the primary cache by default.

Prerequisites to Configure Multi-region ASP.NET Core Session Provider

• .NET

• Install the following NuGet packages in your application based on your NCache edition:
  • Enterprise: AspNetCore.Session.NCache
  • Professional: AspNetCore.Session.NCache.Professional
  • OpenSource: AspNetCore.Session.NCache.OpenSource
• To utilize the extension, include the following namespaces in your application in Startup.cs:
  • Alachisoft.NCache.Web.SessionState
• The cache must be running.
• For API details, refer to: AddNCacheSession, UseNCacheSession.
• Make sure that the data being added is serializable.
• To ensure the operation is fail-safe, it is recommended to handle any potential exceptions within your application, as explained in Handling Failures.
• To handle any unseen exceptions, refer to the Troubleshooting section.

Step 1: Configure Services

The session management service needs to be initialized. In Startup.cs, use the AddNCacheSession 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 Startup.cs.
2. In JSON format in Appsettings.json.

Method 1: Specifying Configurations in Startup.cs

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. It is also required to specify a directory that is shared by both applications.

Note

The cache prefix should be a maximum of 4 characters long.

public void ConfigureServices(IServiceCollection services)
{
    // Add framework services
    services.AddMvc();
    services.AddDataProtection()
    .PersistKeysToFileSystem(new DirectoryInfo(dir))
    .SetApplicationName("SharedCookieApp");

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

Method 2: Specifying Configurations in Appsettings.json

The session management service needs to be initialized. In Startup.cs, use the AddNCacheSession 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.

Note

The cache prefix should be a maximum of 4 characters long.

"NCacheSettings": {
    "EnableLocationAffinity": true,
    "EnableLogs": true,
    "RequestTimeout": 5,
    "CacheName": "LondonCache",
    "AffinityMapping": [
      {
        "CacheName": "LondonCache",
        "CachePrefix": "LDNC"
      },
      {
        "CacheName": "NewYorkCache",
        "CachePrefix": "NYKC"
      },
      {
        "CacheName": "TokyoCache",
        "CachePrefix": "TKYC"
      }
    ]
}

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

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

Step 2: Add Middleware to the Application

Once the services have been initialized, you can 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 the 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?}");
    });
}

Additional Resources

NCache provides a sample application for Session Caching on GitHub.

See Also

.NET: Alachisoft.NCache.Web.SessionState namespace.