Fala Galera,

Como todos sabemos a largura de banda de nossa rede é um recurso limitado. Reduzir o tamanho do tráfego que nossas APIs retornam faz que o seu aplicativo se torne muito mais performático. Para isso, temos que nos preocupar com o tamanho das resposta que nossas APIs trafegam.

Para melhorar o tamanho dos dados trafegados nas respostas das APIs podemos utilizar técnicas de compressão que visam reduzir o seu tamanho comprimindo o tamanho das respostas e utilizando compactadores como gzip, brotli e entre outros.

A compressão de respostas pode ser feita no ASP.NET Core e nos servidores web como o IIS, Apache e Nginx. Infelizmente o Kestrel e o HTTP.sys ainda não oferece suporte a compressão de resposta.

Configurando o Middleware de Compressão no ASP.NET Core

O ASP.NET Core oferece Middlewares úteis e nestes Middlewares estão contidos o de compressão de resposta.

Vamos utilizar o Middleware de compressão adicionando o pacote “Microsoft.AspNetCore.ResponseCompression” conforme imagem abaixo:

Com o pacote instalado vamos criar nosso compactador. Vamos utilizar o Brotli, o compactador Brotli é aceito pelos browsers atuais e sua compactação é muito boa.

Crie uma classe chamada BrotliCompressionProvider e coloque o código conforme mostrado abaixo:

public class BrotliCompressionProvider : ICompressionProvider
{
    public string EncodingName => "br";
    public bool SupportsFlush => true;
    public Stream CreateStream(Stream outputStream) => new BrotliStream(outputStream, CompressionLevel.Fastest);
    
}

Na classe acima estamos utilizando a propriedade “EncodingName”, nesta propriedade estamos colocando o valor “br”, significa que toda a vez que nossa API for chamada passando o header “Accept-Enconding” na requisição com o valor “br” nossa API irá compactar os dados utilizando o compactador Brotli

Agora que nossa classe está pronta, vamos entrar no Startup.cs e configurar o uso do Brotli.

Coloque o código conforme mostrado abaixo:

public class Startup
   {
       public Startup(IConfiguration configuration)
       {
           Configuration = configuration;
       }
       public IConfiguration Configuration { get; }
       // This method gets called by the runtime. Use this method to add services to the container.
       public void ConfigureServices(IServiceCollection services)
       {
           //Configurando a compactação de resposta
           services.AddResponseCompression(options =>
           {
               options.EnableForHttps = true;
               options.Providers.Add<BrotliCompressionProvider>();
               options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(new[] { "application/json" });
           });
           services.AddControllers();
       }
       // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
       public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
       {
           if (env.IsDevelopment())
           {
               app.UseDeveloperExceptionPage();
           }
           app.UseHttpsRedirection();
           app.UseRouting();
           app.UseAuthorization();
           //Ative a compactação de resposta 
           app.UseResponseCompression();
           app.UseEndpoints(endpoints =>
           {
               endpoints.MapControllers();
           });
       }
   }

Pronto, a compactação está configurada! Vamos testar.

Testando a compactação com o Postman

Para testar a compactação, criei uma API conforme código abaixo, essa API está voltando somente um texto “Lorem Ipsum” para finalidade de testes

[ApiController]
   [Route("[controller]")]
   public class CompressionTestController : ControllerBase
   {
       [HttpGet]
       public String Get()
       {
           return @"
                   Lorem ipsum dolor sit amet, 
                   consectetur adipiscing elit. In eget ante ac orci sollicitudin facilisis id non nisi. Etiam quis libero turpis. Cras lorem ex, molestie sed suscipit vel, ultricies vitae turpis. In quis erat eget nulla        
                   ";
       }
   }

Conclusão

Como vocês podem ver nas imagem acima, a compressão utilizando Brotli teve uma eficácia de 42% em média. Com isso nossa API trafega muito menos dados poupando recursos em nossa rede.

O código deste artigo se encontra no meu Github através deste link

E ai gostaram? Comenta aí =]

Abs e até a próxima!