Skip to main content

How to Improve performance of REST APIs

Ways to improve REST API performance and best practices

Use Compression Techniques

Use compression techniques like gzip or Brotli to compress the data transferred from server to client. .NET Core has an inbuilt Response Compression Middleware for compression (default: gzip). GZIP is used for file compression and decompression for faster network transfer. Also, reducing the size of the response usually increases the responsiveness


Use Asynchronous methods

Asynchronous methods help to maximize the number of concurrent requests that can be handled by the API at a given point in time. By implementing asynchronous methods, you can leverage the multiple cores of the server and maximise application's throughput. Increases Scalability.

Call data access, I/O and long-running operations asynchronously


Use faster Data Access Strategies

In order for an app to be responsive, it is essential to retrieve data from database faster and efficiently. One suggestion would be to use ADO.NET over ORM since its lightweight. Also, can look for database query optimizations that can reduce the number of round trips made to to the database by combining multiple calls to a single call.


Use Caching

You can use Caching to cache API methods that return the same response frequently. Few Caching Techniques - Pivotal Cloud Cache (PCC), Redis, .NET Core Lazy Cache, Cloudfare(CDN)


Faster Media Type Formatters

JSON preferred over XML for message transmission since its lightweight


Implement Pagination

Limit the number of records returned in response by implementing Pagination techniques (skip/limit, next/prev APIs)


Understanding Hot Code Paths

A hot code path is a path of code that is called frequently and where most of the execution time occurs. Hot paths limit the application's ability to scale out and limit API performance if it's optimized correctly.


Make Hot Code Paths asynchronous. Profilers like PerfView, Resharper's dotMemory and dotTrace, ANTS Performance Profiler can be used to find hot code paths and also threads that are frequently added to the thread pool


Reduce allocating large objects in HEAP

Garbage collection is really expensive on large objects(>85KB). Unlike gen0 and gen1, gen2 collection needs the temporary suspension of app execution.

Avoid/minimize assigning large objects in Hot Code Paths


Keep Common Code Paths fast

Middleware components run very early in the request pipeline and run for every request. So middlewares like custom logging, authorization handlers or initialization of transient services should be optimized.


Long-running tasks should be performed separately

We should not be waiting for long-running tasks to finish to send the HTTP response back to the client. Instead, consider using background services for handling long-running requests.

Labels:

Comments

Post a Comment

Popular posts from this blog

How to clear Visual Studio Cache

How to clear visual studio cache Many times, during development you would face situations where project references are not loaded properly or you get missing/error DLL's. This is because the Component cache gets corrupted randomly and without any warnings. The first option that needs to be done is to clear component cache and restart Visual Studio since the Cache might be holding onto previous DLL versions. Here are the steps on how to clear Visual Studio Cache, Clearing Component Cache: Close all Visual Studio Instances running in your machine. Also, make sure devenv.exe is not running in the Task Manager Delete the Component cache directory - %USERPROFILE%\AppData\Local\Microsoft\VisualStudio\1x.0\ComponentModelCache Restart Visual Studio The above steps should fix the cache issue most of the times, but some times that is not enough and you need to perform the below steps as well. Clearing User's Temp Folder: Open the temp folder in this locatio n -  %USERPROFILE%\AppData\Loc
223 comments
Read more

PCF Health Check Delay - Invocation timeout

In PCF we can set up the health check invocation timeout to execute X seconds after the instance has been created.  But before that, let's understand the PCF Health Check Lifecycle. Stage 1: The application is deployed to PCF Stage 2: When deploying the app, a health check type is specified and optionally a timeout. If a health check type is not specified, then the monitoring process defaults to a port health check Stage 3: Cloud Controller stages, starts, and runs the application Stage 4: Based on the type specified for the app, Cloud Controller configures a health check    that runs periodically for each app instance Stage 5: When Diego starts an app instance, the app health check runs every two seconds until a response indicates that the app instance is healthy or until the health check timeout elapses. The 2-seconds health check interval is not configurable Stage 6: When an app instance becomes healthy, its route is advertised, if applicable.                  Subsequent hea
1 comment
Read more

How to dependency inject to static class

.Net core supports dependency injection. There are many ways that you can inject services like constructor injection, action method injection, property injection. But there will be scenarios where you need to inject dependency services to static classes. For example, injecting services to extension methods. First, create a static class with a one property IServiceProvider type public void ConfigureServices(IServiceCollection services) { services.AddScoped<ILoggerEntry, LoggerEntry>(); services.AddTransient<IMongoRepository, MongoRepository>(); } Second, configure your services in ConfigureServices() method in Startup.cs and define the lifetime of the service instance using either Transient, Scoped or Singleton types. public void ConfigureServices(IServiceCollection services) { services.AddScoped<ILoggerEntry, LoggerEntry>(); services.AddTransient<IMongoRepository, MongoRepository>(); } For the next step to configure the Static class provider proper
Post a Comment
Read more