{"id":9384,"date":"2023-11-21T14:02:10","date_gmt":"2023-11-21T17:02:10","guid":{"rendered":"https:\/\/elemarjr.com\/clube-de-estudos\/?post_type=artigos&p=9384"},"modified":"2023-12-27T08:47:21","modified_gmt":"2023-12-27T11:47:21","slug":"voce-ja-ouviu-falar-em-back-pressure","status":"publish","type":"artigos","link":"https:\/\/elemarjr.com\/clube-de-estudos\/artigos\/voce-ja-ouviu-falar-em-back-pressure\/","title":{"rendered":"Voc\u00ea j\u00e1 ouviu falar em Back Pressure?"},"content":{"rendered":"\n

Nas aplica\u00e7\u00f5es cliente-servidor, uma quest\u00e3o inescap\u00e1vel \u00e9 o gerenciamento eficiente da alta carga de requisi\u00e7\u00f5es que um servidor pode suportar. Imagine um cen\u00e1rio em que centenas ou milhares de clientes bombardeiam um servidor web simultaneamente. Como ele pode gerenciar essa carga sem sucumbir \u00e0 press\u00e3o?<\/p>\n\n\n\n

A\u00ed entra o conceito de back pressure<\/em>, vital na arquitetura de sistemas distribu\u00eddos. Semelhante \u00e0 press\u00e3o excessiva em um cano que deve ser equalizada para evitar danos, o servidor precisa de um sistema que equilibre a carga para manter a estabilidade. Mas como exatamente isso \u00e9 implementado?<\/p>\n\n\n\n

Vamos a um exemplo pr\u00e1tico em c\u00f3digo C#. Imagine que temos um servidor web ASP.NET Core. Podemos utilizar middlewares para aplicar limita\u00e7\u00e3o de taxa (rate limiting<\/em>) e tratar o back pressure<\/em>. Abaixo, um pseudo-c\u00f3digo simplificado de como poderia ser um middleware de rate limiting<\/em>:<\/p>\n\n\n\n

<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
public<\/span> <\/span>class<\/span> <\/span>RateLimitingMiddleware<\/span><\/span>\n{<\/span><\/span>\n    <\/span>private<\/span> <\/span>readonly<\/span> RequestDelegate _next<\/span>;<\/span><\/span>\n    <\/span>private<\/span> <\/span>readonly<\/span> <\/span>int<\/span> _requestLimit<\/span>;<\/span><\/span>\n    <\/span>private<\/span> <\/span>int<\/span> _requestCount<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>RateLimitingMiddleware<\/span>(<\/span>RequestDelegate next<\/span>,<\/span> <\/span>int<\/span> requestLimit<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>_next<\/span> <\/span>=<\/span> <\/span>next<\/span>;<\/span><\/span>\n        <\/span>_requestLimit<\/span> <\/span>=<\/span> <\/span>requestLimit<\/span>;<\/span><\/span>\n        <\/span>_requestCount<\/span> <\/span>=<\/span> <\/span>0<\/span>;<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>async<\/span> Task <\/span>InvokeAsync<\/span>(<\/span>HttpContext context<\/span>)<\/span><\/span>\n    <\/span>{<\/span><\/span>\n        <\/span>if<\/span> <\/span>(<\/span>_requestCount<\/span> <\/span>>=<\/span> <\/span>_requestLimit<\/span>)<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>context<\/span>.<\/span>Response<\/span>.<\/span>StatusCode<\/span> <\/span>=<\/span> <\/span>StatusCodes<\/span>.<\/span>Status429TooManyRequests<\/span>;<\/span><\/span>\n            <\/span>return;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n<\/span>\n        <\/span>Interlocked<\/span>.<\/span>Increment<\/span>(<\/span>ref<\/span> <\/span>_requestCount<\/span>)<\/span>;<\/span><\/span>\n        <\/span>try<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>await<\/span> <\/span>_next<\/span>(<\/span>context<\/span>)<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>finally<\/span><\/span>\n        <\/span>{<\/span><\/span>\n            <\/span>Interlocked<\/span>.<\/span>Decrement<\/span>(<\/span>ref<\/span> <\/span>_requestCount<\/span>)<\/span>;<\/span><\/span>\n        <\/span>}<\/span><\/span>\n    <\/span>}<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Este middleware controla o n\u00famero de requisi\u00e7\u00f5es concorrentes e rejeita qualquer nova requisi\u00e7\u00e3o com um status HTTP 429 assim que o limite \u00e9 alcan\u00e7ado, indicando ao cliente que deve tentar novamente mais tarde.<\/p>\n\n\n\n
Back pressure<\/em> pode envolver t\u00e9cnicas mais sofisticadas, como filas e sistemas de mensagens, onde a carga \u00e9 gerenciada distribuindo-a uniformemente. A ideia n\u00e3o \u00e9 simplesmente rejeitar o excesso, mas comunicar de volta ao cliente, potencialmente com uma mensagem como “Tente novamente ap\u00f3s X segundos”, para que ambos, cliente e servidor, possam se ajustar de maneira din\u00e2mica e inteligente.<\/p>\n\n\n\n
Al\u00e9m disso, examinemos a degrada\u00e7\u00e3o graciosa. Um exemplo deste conceito \u00e9 um servi\u00e7o web que, sob carga pesada, desativa temporariamente funcionalidades secund\u00e1rias para dedicar recursos \u00e0s fun\u00e7\u00f5es cr\u00edticas, mantendo o servi\u00e7o operando, embora em capacidade reduzida.<\/p>\n\n\n\n
Um caso conhecido de aplica\u00e7\u00e3o bem-sucedida de t\u00e9cnicas de back pressure<\/em> e degrada\u00e7\u00e3o graciosa \u00e9 o da Netflix. A plataforma utiliza uma s\u00e9rie de padr\u00f5es de resili\u00eancia para gerenciar a distribui\u00e7\u00e3o de conte\u00fado para milh\u00f5es de usu\u00e1rios. Diante de uma falha ou sobrecarga, seus sistemas s\u00e3o projetados para degradar de maneira controlada, preservando a experi\u00eancia do usu\u00e1rio final.<\/p>\n\n\n\n
Finalmente, vale a pena mencionar as pr\u00e1ticas de teste de carga e simula\u00e7\u00f5es de falha. Estas s\u00e3o ferramentas preciosas para validar a robustez de uma arquitetura contra cen\u00e1rios de alta demanda. Frameworks como Gatling ou JMeter podem ser utilizados para simular requisi\u00e7\u00f5es em massa e avaliar como a aplica\u00e7\u00e3o sob teste responde a back pressure<\/em>.<\/p>\n\n\n\n
Conclus\u00e3o<\/h1>\n\n\n\n
Abordar conceitos como back pressure<\/em>, rate limiting<\/em> e degrada\u00e7\u00e3o graciosa significa entender os alicerces da resili\u00eancia em arquitetura de software. Essas estrat\u00e9gias s\u00e3o fundamentais para que sistemas distribu\u00eddos se mantenham confi\u00e1veis sob demandas vari\u00e1veis. A aplica\u00e7\u00e3o pr\u00e1tica desses conceitos, refor\u00e7ada por exemplos reais e testes rigorosos, \u00e9 um passo crucial para arquitetos e desenvolvedores. Estes temas, suas implementa\u00e7\u00f5es e pr\u00e1ticas associadas s\u00e3o explorados em profundidade em meus grupos de estudos e mentorias, permitindo aprofundar o conhecimento e compartilhar experi\u00eancias.<\/p>\n\n\n\n
TL;DR<\/h1>\n\n\n\n
    \n
  1. Back pressure<\/em> \u00e9 um conceito essencial para a gest\u00e3o de alta carga em servidores, assegurando estabilidade e evitando sobrecarga.<\/li>\n\n\n\n
  2. Exemplos em C# e a aplica\u00e7\u00e3o de middlewares no ASP.NET Core ilustram como realizar rate limiting<\/em> em aplica\u00e7\u00f5es pr\u00e1ticas.<\/li>\n\n\n\n
  3. Casos reais como o da Netflix exemplificam a implementa\u00e7\u00e3o de degrada\u00e7\u00e3o graciosa e pr\u00e1ticas de teste de carga s\u00e3o vitais para validar a resili\u00eancia da arquitetura de software.<\/li>\n<\/ol>\n","protected":false},"featured_media":9385,"parent":0,"template":"","cursos":[16],"class_list":["post-9384","artigos","type-artigos","status-publish","has-post-thumbnail","hentry","cursos-arquitetura-de-software"],"acf":[],"_links":{"self":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/artigos\/9384","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/artigos"}],"about":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/types\/artigos"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/media\/9385"}],"wp:attachment":[{"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/media?parent=9384"}],"wp:term":[{"taxonomy":"cursos","embeddable":true,"href":"https:\/\/elemarjr.com\/clube-de-estudos\/wp-json\/wp\/v2\/cursos?post=9384"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}