<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Marcio Rodrigues on Medium]]></title>
        <description><![CDATA[Stories by Marcio Rodrigues on Medium]]></description>
        <link>https://medium.com/@marciorodrigues_79112?source=rss-59367b650a4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*-gwOezGMiN3TflWF.</url>
            <title>Stories by Marcio Rodrigues on Medium</title>
            <link>https://medium.com/@marciorodrigues_79112?source=rss-59367b650a4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 03:43:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@marciorodrigues_79112/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Migração sem sofrimento]]></title>
            <link>https://medium.com/tech-grupozap/migra%C3%A7%C3%A3o-sem-sofrimento-eb9c97e720?source=rss-59367b650a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb9c97e720</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[server-side-rendering]]></category>
            <category><![CDATA[backend]]></category>
            <dc:creator><![CDATA[Marcio Rodrigues]]></dc:creator>
            <pubDate>Tue, 09 Oct 2018 17:52:32 GMT</pubDate>
            <atom:updated>2018-10-10T13:49:37.657Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Com uma boa arquitetura, testes A/B e chaveamento na borda</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/825/1*EZtp829WN9l-CMOj9O017g.jpeg" /></figure><h3>O contexto</h3><p>Durante alguns anos no VivaReal, muitas pessoas trabalharam para substituir um grande legado monolítico por uma <em>stack</em> mais sustentável, baseada em <em>microservices</em> com responsabilidades mais definidas, <em>deployments</em> independentes, tolerância a falhas mais efetiva, etc. Enfim, uma <em>stack</em> moderna e pronta para mudanças e novas <em>features</em>.</p><p>Eu tive o prazer de acompanhar a última milha dessa longa jornada. Que foi a migração do <a href="https://www.vivareal.com.br/">https://www.vivareal.com.br/</a> para um dos últimos sistemas dessa <em>stack</em> a ficar pronto: o <em>render</em>!</p><p>Mas, antes de mais nada, eu separei artigos de outras pessoas que escreveram sobre outras partes dessa aventura:</p><ul><li>O <a href="https://medium.com/@ricardohbin">Bin</a> fala sobre como foi a <a href="https://medium.com/tech-grupozap/quebrando-o-lado-obscuro-das-aplica%C3%A7%C3%B5es-monol%C3%ADticas-parte-1-e733b0f0fae1">separação dos <em>assets</em> e <em>templates</em></a> que possibilitou a transição para o novo <em>render</em> ser tão tranquila e transparente para o <em>frontend</em>.</li><li>A <a href="https://medium.com/@sabrinajn">Sabrina</a> fala sobre o início dos <a href="https://medium.com/tech-grupozap/come%C3%A7ar-e-manter-uma-su%C3%ADte-de-testes-8d3d1534a9f3">testes e2e no site do VivaReal</a> que possibilitou realizarmos muitos <em>refactorings. </em>Além de pegar alguns <em>bugs</em> bem chatos durante o desenvolvimento do novo <em>render</em>.</li><li>O <a href="https://medium.com/@ericksson.faustino">Erick</a> fala sobre o início do <a href="https://medium.com/tech-grupozap/a-plataforma-d06fcf84f52c">time de plataforma</a> que mantém serviços vitais para o funcionamento dos sites (provavelmente o maior <em>cluster</em> de <em>Kubernetes</em> do Brasil é o nosso)!</li><li>E nesse <a href="https://medium.com/tech-grupozap/facade-para-organiza%C3%A7%C3%A3o-de-microservices-c31ce6be76f">outro post</a> eu falo em como fizemos para juntar todos os dados de todos os <em>microservices</em> que existem aqui no Grupo Zap para o <em>frontend</em> e o <em>render</em> utilizarem!</li></ul><h3>A estratégia</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/670/1*-9jc99zamPjNWhtT4Mp8rA.jpeg" /></figure><p>Como os <em>assets</em> já estavam separados, nós decidimos fazer o chaveamento na borda e o novo <em>render</em> (feito em <em>NodeJs</em>) e o antigo <em>render</em> (um pedaço já bem pequeno do legado monolítico em <em>Java</em>) acessariam sempre a última versão dos <em>assets</em> na mesma origem.</p><p>O desafio nesse ponto foi encontrar uma maneira de fazer esses dois sistemas coexistirem servindo no mesmo domínio. Sendo que o novo render deveria ser utilizado somente quando um determinado parâmetro estivesse presente na <em>query string</em>, por exemplo ?__vt=ch:a , faz com que um <em>request</em> recebido seja servido pelo novo <em>render</em> e sem o parâmetro pelo antigo.</p><h4>Duas origens para o mesmo domínio</h4><p>Como utilizamos a <a href="https://www.cloudflare.com/"><em>Cloudflare</em></a> como nosso servidor de borda, fomos logo pesquisar se havia alguma forma de fazer diretamente lá… e sim, existe uma <em>feature</em> muito interessante chamada Resolve Override que se encaixou exatamente nas nossas necessidades! Com ela podemos, dada uma expressão de URL, por exemplo, https://www.vivareal.com.br/venda/*__vt=ch:a* , selecionar um outro servidor como origem, <a href="https://support.cloudflare.com/hc/en-us/articles/206190798-Using-Resolve-Override-in-Page-Rules">aqui</a> tem um exemplo mais concreto.</p><p>Assim conseguimos chegar em um cenário bastante favorável para a nossa migração:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*xH0QIyb5qAkRrTk_Nvdq6Q.png" /></figure><h4>Seleção de usuários para usar o novo render</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*TFDCkgvHchV_4bpN7Rz_hw.jpeg" /><figcaption><a href="https://blog.masterofproject.com/sampling-methods/">Fonte</a></figcaption></figure><p>Para a seleção de usuários que seriam os nossos <em>beta testers</em> nós utilizamos uma ferramenta de testes A/B, o <a href="https://marketingplatform.google.com/about/optimize/">Google Optimize</a>. Com ela conseguimos direcionar qualquer percentual dos nossos usuários para essa URL com o parâmetro na <em>query string</em> que era servida pelo novo <em>render</em>.</p><p>Como a ferramenta já era utilizada no site do Viva Real, foi realmente muito simples aproveitá-la para o nosso propósito.</p><h4>Baby steps</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/628/1*qfulS2Z_w--ipuNlPY4mkg.jpeg" /></figure><p>Com a forma de chaveamento entre os <em>backends</em> e a seleção dos usuários definidos, nós começamos a fazer a virada para o novo <em>render</em> uma página por vez.</p><p>Primeiro as páginas mais simples até chegar nas mais complexas. Sempre acompanhando os erros que ocorriam e corrigindo-os rapidamente.</p><p>Também conseguimos comparar o tempo de resposta dos dois <em>backends</em> e fazer ajustes quando necessário.</p><p>Quando algo dava muito errado, nós simplesmente desligávamos o teste A/B ou a regra de chaveamento na borda, corrigíamos o problema e começávamos novamente.</p><h3>Conclusão</h3><p>Dessa forma conseguimos realizar a virada de um <em>backend</em> para outro com muita tranquilidade e, além de tudo, conseguimos acompanhar diversas métricas entre o antigo e novo <em>backends.</em> Por exemplo: conversão, <em>bounce rate,</em> tempo de resposta, percentual de erros e muitas outras.</p><p>Isso só foi possível por que nós delimitamos sempre as mudanças ao menor tamanho possível. Isso fez com que algumas novas funcionalidades e sistemas fossem utilizados primeiro no legado e, sim, implementamos um monte de coisas que foram jogadas fora. Mas poder fazer essa virada de forma tão sustentável e segura valeu a pena cada linha de código. Até aquelas que ficaram em produção somente algumas semanas.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb9c97e720" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tech-grupozap/migra%C3%A7%C3%A3o-sem-sofrimento-eb9c97e720">Migração sem sofrimento</a> was originally published in <a href="https://medium.com/tech-grupozap">Tech@Grupo ZAP</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Facade para organização de Microservices]]></title>
            <link>https://medium.com/tech-grupozap/facade-para-organiza%C3%A7%C3%A3o-de-microservices-c31ce6be76f?source=rss-59367b650a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/c31ce6be76f</guid>
            <category><![CDATA[grupo-zap]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[facade]]></category>
            <category><![CDATA[backend]]></category>
            <dc:creator><![CDATA[Marcio Rodrigues]]></dc:creator>
            <pubDate>Mon, 10 Sep 2018 19:15:50 GMT</pubDate>
            <atom:updated>2018-09-10T19:15:50.513Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uEhNvyXWxL-dCFGTw7w_Qg.png" /><figcaption>Fachada</figcaption></figure><p>Com a ascensão dos <em>microservices</em> surgiram diversos desafios como <em>overhead</em> de rede e recursos, transações distribuídas, granularidade dos serviços, rastreabilidade de transações, operação e administração de sistemas, padronização e organização, ressonância de erros, tolerância a falhas, versionamento de APIs e muitos outros.</p><p>Aqui pretendo demonstrar as vantagens de extrapolar o famigerado <em>Design Pattern Facade</em> para o mundo dos <em>microservices</em>, principalmente para organização dos serviços, prevenção de dependências cíclicas entre eles e otimização de recursos, evitando alguns dos problemas acima.</p><h3>Dependências cíclicas</h3><p>Uma das piores práticas (ou acontecimento, na maioria das vezes é sem querer) em engenharia de software.</p><p>Se temos um sistema com diversos componentes (podem ser módulos de um sistema monolítico, serviços de uma arquitetura SOA, <em>microservices</em>, enfim, qualquer unidade de código), sem um <em>facade</em> responsável por encadear chamadas, completar detalhes de entidades e descrever programaticamente o fluxo de um processamento, a chance de criarmos dependências cíclicas é bem grande.</p><p>Esse componente não pode conter nenhuma regra de negócio específica (num mundo ideal, não deveria conter nenhum if), apenas as chamadas para outros componentes especializados em determinada tarefa necessária para aquele fluxo de processamento.</p><p>Aqui temos um exemplo fictício de um sistema <strong>sem</strong> o <em>facade</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/461/1*FdJpgEW0qdD9GdUq2reNEw.png" /></figure><p>Note que temos diversas dependências cíclicas nesse exemplo (diretas e indiretas), também percebemos uma <strong>alta</strong> <strong>complexidade </strong>na comunicação entre os componentes, a chance de existirem <strong>chamadas repetidas</strong> para obtenção de um mesmo dado é grande.</p><p>Nada impede (em termos de desenho da solução) que <strong>mais dependências cíclicas sejam criadas</strong>, e isso vai acontecer conforme esse exemplo se tornar mais complexo, com adição de mais componentes e mais fluxos. O <em>troubleshooting</em> do fluxo também é bastante espalhado, o <strong>fluxo não parece claro</strong> num simples desenho, o código então, nem se fala.</p><h4>Facade ao resgate</h4><p>Vamos reorganizar esse sistema utilizando uma camada a mais, o <em>facade</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/402/1*HgtWVJGV_BCMRcdoxnTINA.png" /></figure><p>Com essa nova organização, conseguimos:</p><ul><li>Ver o <strong>fluxo com mais clareza.</strong></li><li>Os componentes especializados não precisam conhecer outros componentes especializados, <strong>apenas os dados</strong> que eles fornecem.</li><li>O fluxo é descrito <strong>programaticamente.</strong></li><li>As chamadas podem ser feitas <strong>paralelamente.</strong></li><li>Se um dos componentes falhar, o <em>facade</em> pode decidir se é uma falha catastrófica ou se é uma <strong>falha tolerável.</strong></li><li>O <em>facade</em> pode controlar uma <strong>transação</strong> se necessário, de forma a <strong>encapsular essa complexidade</strong> e muitas outras!</li></ul><p>São diversos benefícios! Esse desenho incentiva também o <strong>SRP</strong> (<em>Single Responsibility Principle</em>).</p><h3>Organização dos serviços</h3><p>Com o <em>facade</em> a tendência passa a ser pensar em componentes com <strong>menos responsabilidades</strong> e com a simplificação das dependências entre eles para apenas dados, obtemos uma <strong>organização natural</strong> do fluxo de processamento. Como os componentes não se integram diretamente o foco passa a ser em receber os <strong>dados necessários, efetuar um processamento e fornecer uma saída relevante</strong> para ser utilizada por outros componentes do sistema.</p><h3>Otimização de recursos</h3><p>O <em>facade</em> ajuda a reduzir o <em>overhead</em> de rede, principalmente se ele for posicionado como ponto de entrada público para um processamento. Tráfego público é <strong>mais caro e mais lento</strong> do que tráfego privado.</p><p>Por exemplo, fazer 10 chamadas diretamente do front-end, indo e voltando será mais lento e caro do que fazer apenas uma chamada para o <em>facade</em> e receber todos os dados necessários de uma vez só, principalmente se os seus servidores estiverem longe, nos EUA ou em algum outro país em que o preço deles seja mais barato do que no Brasil.</p><h3>Não existe receita pronta!</h3><p>Esse artigo foi inspirado em como organizamos um sistema para fornecer todas as informações necessárias para os sites e aplicativos do Grupo Zap. Tanto as utilizadas diretamente no <em>frontend</em> quanto no <em>backend</em> ou em <em>workers</em> que enviam e-mails, por exemplo.</p><p>Cada situação deve ser analisada individualmente! Existem casos em que não vale a pena seguir o modelo proposto aqui:</p><ul><li>Um CRUD simples.</li><li>Sistemas com apenas uma dependência externa.</li><li>Sistemas especializados em uma tarefa específica e delimitada (cálculos, renderização…).</li></ul><p>Devemos sempre primar pela simplicidade!</p><h3>Conclusão</h3><p>Apesar de estarem fora de moda, alguns <em>Design Patterns</em> ainda podem ser muito úteis mesmo nos dias de hoje.</p><p>O <em>facade</em> introduz um nível de organização extremamente alto a qualquer código em qualquer nível: design, arquitetura lógica e física. Mas o seu maior benefício, na minha opinião, está relacionado a prevenir dependências cíclicas, elas acabam com a vida útil de qualquer sistema, pois a cada nova funcionalidade ele fica mais complexo e mais difícil de manter.</p><h3>Mais informações</h3><p><a href="https://en.wikipedia.org/wiki/Facade_pattern">https://en.wikipedia.org/wiki/Facade_pattern</a></p><p><a href="https://en.wikipedia.org/wiki/Single_responsibility_principle">https://en.wikipedia.org/wiki/Single_responsibility_principle</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c31ce6be76f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tech-grupozap/facade-para-organiza%C3%A7%C3%A3o-de-microservices-c31ce6be76f">Facade para organização de Microservices</a> was originally published in <a href="https://medium.com/tech-grupozap">Tech@Grupo ZAP</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Alta disponibilidade com Kubernetes na prática]]></title>
            <link>https://medium.com/tech-grupozap/alta-disponibilidade-com-kubernetes-na-pr%C3%A1tica-b9cf4261d2f7?source=rss-59367b650a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/b9cf4261d2f7</guid>
            <category><![CDATA[circuit-breaker]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Marcio Rodrigues]]></dc:creator>
            <pubDate>Thu, 12 Jul 2018 18:37:27 GMT</pubDate>
            <atom:updated>2018-07-12T18:37:27.954Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*XvPvByezUf6TBQogBhDLHQ.jpeg" /><figcaption>Orquestração de containers na vida real</figcaption></figure><p>O <a href="https://kubernetes.io/">Kubernetes</a> é um sistema open source para automação de <em>deployments</em>, <em>scaling</em> e gerenciamento de containers. Está em constante evolução e tem uma comunidade extremamente ativa e dinâmica.</p><p>Um <em>deployment</em> de aplicação no Kubernetes criado com configuração padrão não vai ter HA (<a href="https://en.wikipedia.org/wiki/High_availability"><em>High Availability</em></a>).</p><p>Abaixo, listo algumas coisas que aprendemos ao longo de quase um ano e meio com uma aplicação crítica em produção.</p><p>No final do artigo, coloquei um <a href="https://gist.github.com/marciorodrigues87/56eb40fe6878c9c7dff50ed47314e13a">exemplo completo</a> com todas essas coisas nos seus devidos lugares!</p><h3>Rollout</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/476/1*1ZCp8RSW_wJr_ABvtjBnAA.png" /></figure><p>Um <em>rollout</em> ocorre sempre que alguma alteração é feita no seu deployment. A seguir temos uma configuração que garante HA durante esse processo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/36ebe79077744ed17e391b5ad4244db2/href">https://medium.com/media/36ebe79077744ed17e391b5ad4244db2/href</a></iframe><p>Vamos ver o que cada parte significa:</p><h4>replicas</h4><p>Aqui temos a quantidade de réplicas que serão criadas nesse <em>rollout</em>. É importante saber que a quantidade atual de réplicas não é levada em conta, então uma boa estratégia é ler a quantidade atual de réplicas e substituir no seu arquivo de <em>deployment</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/37727b546bcb5200feb00720e1577cd8/href">https://medium.com/media/37727b546bcb5200feb00720e1577cd8/href</a></iframe><p>Assim evitamos que uma aplicação rodando com muitas réplicas fique com uma quantidade insuficiente após o processo de <em>rollout</em>.</p><h4>minReadySeconds</h4><p>Nessa opção configuramos o tempo (em segundos), que os <em>pods</em> criados pelo seu <em>deployment</em> irão esperar para estarem disponíveis. Se sua aplicação consome muita CPU na inicialização, essa configuração pode ser uma ótima alternativa para estabilização dos <em>pods</em> antes de começarem a receber requisições.</p><h4>rollingUpdate</h4><p>Essa estratégia cria um novo <em>ReplicaSet</em> a partir das alterações feitas no <em>deployment</em> e vai diminuindo a quantidade de <em>pods</em> do <em>ReplicaSet</em> antigo, à medida que consegue aumentar a quantidade de <em>pods</em> do <em>ReplicaSet</em> novo. Dessa forma o <em>rollout</em> ocorre gradativamente e é possível acompanhar se quantidade de erros/tempo de resposta aumentam durante o processo.</p><h4>maxSurge</h4><p>Nesse campo especificamos a quantidade de <em>pods</em> que o novo <em>ReplicaSet</em> vai criar a mais antes de começar a terminar os <em>pods</em> do antigo <em>ReplicaSet</em>. Quanto maior o valor, mais rápido o <em>rollout</em> ocorre.</p><h4>maxUnavailable</h4><p>Essa é a principal opção para atingirmos HA no processo de <em>rollout</em>. Por padrão, o Kubernetes define uma margem de 25%, então, caso não coloquemos 0 (que significa sem nenhum <em>pod</em> indisponível), existe a possibilidade da aplicação ficar com uma quantidade insuficiente de <em>pods</em> no momento do <em>rollout</em>, as chances de indisponibilidade aumentam consideravelmente.</p><h3>Healthcheck</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*edM6LaQ888fo2j-9hlBRxA.png" /></figure><p>Sua aplicação deve prover um <em>endpoint</em> que diga para o <em>deployment</em> que uma instância está realmente pronta para receber tráfego.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/932ef3d8c3e561c36e267990b4a3860f/href">https://medium.com/media/932ef3d8c3e561c36e267990b4a3860f/href</a></iframe><p>Vamos às explicações:</p><h4>livenessProbe</h4><p>Essa seção é usada pelo Kubernetes para verificar se os pods da sua aplicação estão funcionais. Se em algum momento, dadas a configurações, essa verificação falhar, o seu <em>pod</em> será reiniciado. Boas práticas para a implementação desse <em>endpoint</em> são checar conectividade com as dependências, espaço em disco e tudo que possa influenciar no funcionamento da aplicação.</p><h4>readinessProbe</h4><p>Durante um <em>rollout</em> o Kubernetes usa essa seção para saber se os <em>pods</em> da sua aplicação estão prontos para receber tráfego. É muito importante para obter HA durante o processo de <em>rollout</em>. Boas práticas para a implementação desse <em>endpoint</em> incluem <em>Signal Handling</em>, por exemplo, encerrar conexões persistentes quando receber SIGTERM ou SIGINT, aguardar dados necessários estarem em memória, conexões com dependências estabelecidas, etc.</p><h4>failureThreshold</h4><p>Informa quantas vezes uma falha deve ocorrer para a verificação ser considerada com falha e o <em>pod</em> da aplicação sofrer um <em>restart</em> ou não receber tráfego.</p><h4>httpGet</h4><p>Como estamos falando de uma API HTTP, usamos esse campo para configurar o <em>path</em> e porta onde o Kubernetes vai bater para as verificações de readiness e liveness.</p><h4>initialDelaySeconds/periodSeconds</h4><p>De quanto em quanto tempo o Kubernetes vai executar as verificações, sendo que a primeira pode ter um valor diferente das subsequentes. Se a aplicação demora para inicializar, vale a pena colocar um valor próximo desse tempo.</p><h3>Distribuição de Pods</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*hAfoNYmUIXNYnWqumcvy3A.png" /></figure><p>É muito importante garantir que os <em>pods</em> da sua aplicação não estão concentrados em poucos <em>nodes</em> do <em>cluster</em>, pois em caso de alguma falha no <em>cluster</em>, quanto mais bem distribuídos estiverem seus <em>pods</em>, menor o impacto. Para isso é possível configurar uma anti afinidade entre os <em>pods</em> da sua aplicação, por exemplo, para que eles nunca fiquem em um mesmo <em>node</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e1c27cd9fa7a8ddd7720f5d5e75615ad/href">https://medium.com/media/e1c27cd9fa7a8ddd7720f5d5e75615ad/href</a></iframe><h4>podAntiAffinity</h4><p>Nessa seção especificamos que, segundo os critérios definidos, novos <em>pods</em> da aplicação não vão ficar em um <em>node</em> que já tenha um <em>pod</em> da mesma aplicação.</p><h4>requiredDuringSchedulingIgnoredDuringExecution</h4><p>Com essa configuração definimos que as regras de anti afinidade serão aplicadas somente durante eventos de <em>scale</em>, ou seja, se um <em>pod</em> for editado para conter algum dos critérios da regra durante sua execução, isso não vai fazer com que a regra seja aplicada.</p><h4>labelSelector</h4><p>Essa seção define que vamos usar <em>labels</em> dos <em>pods</em> para verificação da regra. Você pode colocar <em>labels</em> nos metadados dos seus <em>pods</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b14eb0d6a64ea307f46ebda83d40f357/href">https://medium.com/media/b14eb0d6a64ea307f46ebda83d40f357/href</a></iframe><h4>matchExpressions</h4><p>Essa parte contém as expressões usadas para verificar se um pod não deve ser colocado em algum componente da topologia do <em>cluster</em>. Nesse exemplo estamos verificando que uma determinada <em>label</em> tenha um determinado valor.</p><h4>topologyKey</h4><p>Como nosso objetivo é distribuição dos <em>pods</em> entre <em>nodes</em> usamos o <em>hostname</em> para definir isso, também poderíamos usar zona, região, tipo de instância, existem várias possibilidades.</p><h3>Alocação de recursos</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Fth4jlIw1b1tlnhIt_aTtg.png" /></figure><p>No Kubernetes existem níveis de qualidade de serviço que o <em>cluster</em> infere dependendo de como você configura os recursos que seus pods vão utilizar. Para ter esse nível de qualidade garantido é necessário sempre ter <em>limits</em> e <em>requests</em> iguais.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0126e04dd95584726f31892ecc617382/href">https://medium.com/media/0126e04dd95584726f31892ecc617382/href</a></iframe><h4>requests</h4><p>Definição de memória e CPU que seus <em>pods</em> vão requisitar para serem colocados em um <em>node</em>, essa é a quantidade mínima de recursos que um <em>node</em> deve ter disponível para receber um <em>pod</em> da aplicação.</p><h4>limits</h4><p>Definição de memória e CPU máximas que seus <em>pods</em> vão poder usar em um <em>node</em> que ele já esteja. Uma vez que ele atingir um dos valores, será reiniciado.</p><p>Com os valores iguais o comportamento de <em>eviction</em> e <em>scheduling</em> do <em>cluster</em> deve ficar mais previsível, já que não há variação nos recursos durante a execução dos <em>pods</em> da aplicação.</p><h3>HPA</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*MWQS-zMa46drpY-A8NXi1A.png" /></figure><p>Para garantir a disponibilidade de sua aplicação (principalmente quando ela não tem estado, como depender de um banco de dados, por exemplo) é importante ter uma forma automática de aumentar a quantidade de réplicas que ela possui. Para isso podemos configurar <a href="https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/">HPA</a> (<em>Horizontal Pod Autoscaler</em>) para nossos <em>deployments</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/20cde2d648fe15f56476c784e3b4543d/href">https://medium.com/media/20cde2d648fe15f56476c784e3b4543d/href</a></iframe><h4>scaleTargetRef</h4><p>Aqui relacionamos esse HPA com o <em>deployment</em> pelo nome.</p><h4>minReplicas</h4><p>Quantidade mínima de <em>pods</em> independente da quantidade de CPU utilizada por eles.</p><h4>maxReplicas</h4><p>Limite de pods que esse HPA vai manter.</p><h4>targetCPUUtilizationPercentage</h4><p>Qual o percentual de CPU que o HPA deve manter. Conforme esse percentual for atingido, novos <em>pods</em> serão criados, ou caso o percentual estiver abaixo, <em>pods</em> serão removidos. Sempre buscando estar o mais próximo possível dele.</p><h3>PDB</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*EIUeEQkLP2kkj1Qn-SRPLQ.png" /></figure><p>Podemos configurar o mínimo de replicas disponíveis de nossa aplicação durante uma manutenção ou recuperação do cluster. Para isso temos o <a href="https://kubernetes.io/docs/tasks/run-application/configure-pdb/">PDB</a> (<em>Pod Disruption Budget</em>).</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/04eb54fbdc76027f951595e04cbffabe/href">https://medium.com/media/04eb54fbdc76027f951595e04cbffabe/href</a></iframe><h4>matchLabels</h4><p>Aqui relacionamos nossos <em>pods</em> com esse PDB através das suas <em>labels</em>.</p><h4>minAvailable</h4><p>Percentual mínimo de <em>pods</em> que devem estar disponíveis em caso de problemas no <em>cluster</em>.</p><p>É importante ficar atento nesse passo para não colocar um <em>minAvailable</em> inatingível, como 100%, pois assim os <em>nodes</em> do <em>cluster</em> que tenham <em>pods</em> da sua aplicação nunca poderão ser terminados, travando atualizações no <em>cluster</em>, por exemplo.</p><h3>Exemplo Completo</h3><p>Juntando todas essas boas práticas chegamos a esse arquivo de configuração com todas elas juntas:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8188df2b063f269898ead660ffb5b8a7/href">https://medium.com/media/8188df2b063f269898ead660ffb5b8a7/href</a></iframe><h3>Circuit Breaker</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/330/1*LcwjdxbHl1Qo9RqCaONT-g.png" /></figure><p>Saindo um pouco das configurações no Kubernetes, uma boa prática de HA é cuidar bem de como sua aplicação se comunica com as suas dependências.</p><p>Por exemplo, não é aceitável que uma aplicação deixe de responder em todos os contextos por conta de uma dependência que esteja fora do ar.</p><p>Para mitigar isso temos um <em>design pattern</em> já bem conhecido e popularizado pela Netflix com o <a href="https://github.com/Netflix/Hystrix"><em>Hystrix</em></a>, que é o <a href="https://martinfowler.com/bliki/CircuitBreaker.html"><em>circuit breaker</em></a>.</p><p>É recomendado tirar vantagem dessa implementação. Mas é importante saber que além dessa proteção na comunicação temos que ter visibilidade do que está acontecendo com os circuitos definidos na aplicação, para isso é importante ter um agregador das métricas de todas as réplicas que sua aplicação irá gerar quando utilizar o <em>Hystrix</em>.</p><p>O <a href="https://github.com/Netflix/Turbine"><em>Turbine</em></a> é o componente responsável por isso na stack da Netflix. Basicamente ele tem um serviço de <em>discovery</em> que busca por instâncias rodando o <em>Hystrix</em> dependendo da implementação feita. Nós acabamos fazendo um fork e implementando um <em>discovery</em> de pods no Kubernetes, que você pode conferir o código aqui: <a href="https://github.com/GrupoZapVivaReal/Turbine/blob/1.x/turbine-contrib/src/main/java/com/netflix/turbine/discovery/KubernetesInstanceDiscovery.java">https://github.com/GrupoZapVivaReal/Turbine/blob/1.x/turbine-contrib/src/main/java/com/netflix/turbine/discovery/KubernetesInstanceDiscovery.java</a></p><p>Existem implementações mais genéricas que também merecem ser conferidas, por exemplo: <a href="https://github.com/fabric8io/kubeflix">https://github.com/fabric8io/kubeflix</a>.</p><p>E finalmente para exibição dessas métricas, existe o <em>Hystrix Dashboard</em>. Basta apontar para o endpoint que o <em>Turbine</em> disponibiliza com todas as métricas agregadas e é possível acompanhar em <em>real time</em> todos os circuitos que a aplicação definiu.</p><h3>Conclusão</h3><p>Com algumas simples configurações e implementações é possível atingir um alto nível de HA com o Kubernetes. Espero que esse artigo forneça uma base para quem está começando a criar seus deployments com essa excelente ferramenta!</p><p>Para se aprofundar mais no assunto recomendo a leitura dos links da documentação oficial que coloquei abaixo!</p><h3>Mais informações</h3><p><a href="https://kubernetes.io/">https://kubernetes.io/</a></p><p><a href="https://en.wikipedia.org/wiki/High_availability">https://en.wikipedia.org/wiki/High_availability</a></p><p><a href="https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#writing-a-deployment-spec">https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#writing-a-deployment-spec</a></p><p><a href="https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#interlude-built-in-node-labels">https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#interlude-built-in-node-labels</a></p><p><a href="https://kubernetes.io/docs/tasks/configure-pod-container/quality-service-pod/#qos-classes">https://kubernetes.io/docs/tasks/configure-pod-container/quality-service-pod/#qos-classes</a></p><p><a href="https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/">https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/</a></p><p><a href="https://kubernetes.io/docs/tasks/run-application/configure-pdb/">https://kubernetes.io/docs/tasks/run-application/configure-pdb/</a></p><p><a href="https://kubernetes.io/docs/concepts/workloads/pods/disruptions/">https://kubernetes.io/docs/concepts/workloads/pods/disruptions/</a></p><p><a href="https://github.com/Netflix/Hystrix">https://github.com/Netflix/Hystrix</a></p><p><a href="https://martinfowler.com/bliki/CircuitBreaker.html">https://martinfowler.com/bliki/CircuitBreaker.html</a></p><p><a href="https://github.com/Netflix/Turbine">https://github.com/Netflix/Turbine</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b9cf4261d2f7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tech-grupozap/alta-disponibilidade-com-kubernetes-na-pr%C3%A1tica-b9cf4261d2f7">Alta disponibilidade com Kubernetes na prática</a> was originally published in <a href="https://medium.com/tech-grupozap">Tech@Grupo ZAP</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pensando melhor sobre conexões HTTP]]></title>
            <link>https://medium.com/tech-grupozap/pensando-melhor-sobre-conex%C3%B5es-http-e7105ccf8b56?source=rss-59367b650a4------2</link>
            <guid isPermaLink="false">https://medium.com/p/e7105ccf8b56</guid>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Marcio Rodrigues]]></dc:creator>
            <pubDate>Mon, 10 Jul 2017 13:13:10 GMT</pubDate>
            <atom:updated>2017-07-10T13:13:10.555Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*u9CI017pb6kyNoeSHzp7Zw.jpeg" /></figure><p>Muitas vezes acabamos configurando as bordas das nossas aplicações, mais especificamente conexões HTTP, com exemplos de documentações dos frameworks que utilizamos, por exemplo o RestTemplatedo <em>Spring</em>, onde vemos somente uma breve referência ao uso de <em>GZIP</em> na documentação oficial:</p><blockquote>To use Apache HttpComponents instead of the native java.net functionality, construct the RestTemplate as follows:</blockquote><pre>RestTemplate template = new RestTemplate(new HttpComponentsClientHttpRequestFactory());</pre><blockquote>Apache HttpClient supports gzip encoding. To use it, construct a HttpComponentsClientHttpRequestFactory like so:</blockquote><pre>HttpClient httpClient = HttpClientBuilder.create().build();<br>ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);<br>RestTemplate restTemplate = new RestTemplate(requestFactory);</pre><p>Outro exemplo é o request, muito usado em <em>Nodejs</em>, na documentação temos algumas referências à <em>agents</em> e <em>pool</em>, mas encontrar um exemplo dá um pouquinho mais de trabalho.</p><blockquote>Request is designed to be the simplest way possible to make http calls. It supports HTTPS and follows redirects by default.</blockquote><pre>var request = require(&#39;request&#39;);<br>request(&#39;http://www.google.com&#39;, function (error, response, body) {<br>  console.log(&#39;error:&#39;, error); // Print the error if one occurred<br>  console.log(&#39;statusCode:&#39;, response &amp;&amp; response.statusCode); // Print the response status code if a response was received<br>  console.log(&#39;body:&#39;, body); // Print the HTML for the Google homepage.<br>});</pre><p>Sei que um desenvolvedor mais experiente e com tempo para pensar provavelmente não utilizará a configuração default. Mas já me deparei algumas vezes com isso em minha carreira.</p><p>Vou tentar criar alguns exemplos úteis e incrementais dessas configurações, tanto em <em>Java</em> quanto em <em>Nodejs</em>.</p><h3>Com o que se preocupar?</h3><h4>Connection pooling</h4><p>Abrir conexões é muito custoso para qualquer aplicação, como qualquer operação de I/O (o DNS é resolvido, um socket é aberto, acontece o handshake se for uma conexão HTTPS, etc). Assim, manter uma certa quantidade de conexões abertas e reutilizá-las, evitando todo esse processamento, pode melhorar bastante a performance da sua aplicação.</p><p>Para isso, no RestTemplate podemos utilizar um HttpClient personalizado:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a039466f7e477a936bd9144c0c2382d7/href">https://medium.com/media/a039466f7e477a936bd9144c0c2382d7/href</a></iframe><p>O HttpClient é um objeto bastante pesado, então o ideal é que tenhamos apenas uma instância dele em nossa aplicação, não se preocupe ele é totalmente <em>Threadsafe</em>.</p><p>No exemplo acima estamos mantendo um máximo de 100 conexões abertas por rota (uma rota é basicamente um conjunto de protocolo:host:porta) e um máximo de 1000 conexões abertas no total (por exemplo tendo 12 rotas, mesmo o total por rota sendo de 100, a soma de todas as conexões abertas não ultrapassará 1000, é sempre bom saber quantas rotas seu HttpClient vai acessar para chegar aos melhores valores para cada caso).</p><p>Com o request a configuração é bem simples, mas requer uma outra dependência.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8808f5beb970084030b21611566e3794/href">https://medium.com/media/8808f5beb970084030b21611566e3794/href</a></iframe><p>Acima temos o agentkeepalive, uma lib feita para gerenciar conexões HTTP, nesse caso configuramos <strong>100</strong> conexões por rota também, o conceito é idêntico ao do HttpClient só que para HTTP devemos usar apenas Agent (uma rota nesse caso é composta por host:porta).</p><h4>GZIP</h4><p>Comprimir os dados trafegados também é muito importante, pois diminui o <em>overhead</em> de rede na hora da comunicação com outros sistemas. No caso do RestTemplate o exemplo da documentação já atende essa necessidade. Porém, se você não quer utilizar compressão (<strong>não recomendado na maioria dos casos</strong>), basta chamar esse método no <em>builder</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5a2a8feab19dc956e421268d504a508a/href">https://medium.com/media/5a2a8feab19dc956e421268d504a508a/href</a></iframe><p>No request a compressão não vem habilitada por padrão, então para habilitar basta:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9197d360d50970a5b519edf3aeaf4372/href">https://medium.com/media/9197d360d50970a5b519edf3aeaf4372/href</a></iframe><p>Essa configuração, no entanto, apenas habilita GZIP para receber conteúdo comprimido (por exemplo, um GET), para enviar conteúdo comprimido (por exemplo, um POST) é um pouco mais complicado, pois é necessário adicionar os <em>headers</em> apropriados e fazer a compressão do <em>body</em> na mão:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e524a628f8a9bf24f0f7f962652aa788/href">https://medium.com/media/e524a628f8a9bf24f0f7f962652aa788/href</a></iframe><h4>DNS</h4><p>Se sua infraestrutura é totalmente estática, ou seja, você não usa DNS para resolução de hosts, seu IP de destino nunca irá mudar. Nesse caso, é melhor que as conexões que você mantém abertas no seu <em>connection pool</em> fiquem lá o máximo de tempo possível. Para isso, no RestTemplate, não precisamos fazer nenhuma configuração adicional e no request podemos substituir o agentkeepalive pelo forever-agent, desta forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1654822aa40ab8f4aae240a4f4557d7e/href">https://medium.com/media/1654822aa40ab8f4aae240a4f4557d7e/href</a></iframe><p>O forever-agent é uma lib que mantém suas conexões abertas para sempre (pelo menos enquanto elas estiverem em uso).</p><p>Agora, se você tem uma infraestrutura dinâmica, estará sujeito a mudanças de IPs de hosts, por exemplo, em um <em>blue/green deployment</em>, onde a infraestrutura é imutável e tende a ser sempre substituída por uma nova, com novos IPs. Neste caso, é necessário ter um tempo máximo de vida para suas conexões, senão sua infraestrutura anterior (blue) nunca vai poder ser desligada e sua infraestrutura atual (green) vai receber requests apenas das novas conexões que forem abertas sob demanda. Para configurar esse tempo máximo de vida no RestTemplate é só fazer o seguinte:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fa999a0611b89bf2dc6635f5a3c5f0cb/href">https://medium.com/media/fa999a0611b89bf2dc6635f5a3c5f0cb/href</a></iframe><p>Desta forma, garantimos que nenhuma conexão ficará aberta por mais de <strong>30</strong> minutos, então em uma situação de <em>blue/green</em> temos um tempo bem definido para saber que determinada infraestrutura não está mais sendo usada.</p><p>No request, a configuração é bem similar, utilizando o agentkeepalive (essa <em>feature</em> fomos nós do Viva que implementamos na lib quando identificamos essa necessidade, o PR foi esse <a href="https://github.com/node-modules/agentkeepalive/pull/50">https://github.com/node-modules/agentkeepalive/pull/50</a>):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d1d28de82043cbd2e3a95d209eec91f2/href">https://medium.com/media/d1d28de82043cbd2e3a95d209eec91f2/href</a></iframe><p>O único detalhe aqui é que o <em>TTL</em> é em milissegundos.</p><h4>Retry</h4><p>Em certos casos, retentar um request pode poupar o usuário de tomar um erro na tela, pode poupar sua aplicação de falhar, pode ser… melhor. Por exemplo, sua aplicação tem alguma dependência instável (um cluster que constantemente tem máquinas respondendo normalmente e outras falhando, máquinas sendo reiniciadas, falhas de rede, etc), nesse caso fazer uma retentativa pode garantir que sua aplicação consiga se comunicar ao invés de falhar (ao custo de demorar mais para responder).</p><p>Aqui temos um <em>tradeoff</em> a ser feito: O que é melhor para sua aplicação? Falhar rapidamente ou responder com sucesso porém mais lentamente? Quantas vezes uma retentativa vai ser executada? Devemos diminuir o <em>timeout</em> e confiar que uma retentativa será respondida mais rápido do que a primeira tentativa? Devemos aumentar o <em>timeout</em> e não fazer nenhuma retentativa?</p><p>São vários fatores e responder essa pergunta só é possível com contexto, sabendo disso, vou dar exemplos de como configurar retentativas, primeiro com o RestTemplate:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fdb355d1a1246444753097e6a3f3d25e/href">https://medium.com/media/fdb355d1a1246444753097e6a3f3d25e/href</a></iframe><p>O código acima configura uma quantidade de 3 retentativas, também poderíamos implementar alguma lógica relacionada com a IOException que ocorreu ou com o contexto do <em>request</em>.</p><p>Para retentativas baseadas no <em>response</em> do <em>request</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3bb2f54b5230e44b0f44778a2a3567b8/href">https://medium.com/media/3bb2f54b5230e44b0f44778a2a3567b8/href</a></iframe><p>Aqui utilizamos uma classe útil do HttpClient, a DefaultServiceUnavailableRetryStrategy que recebe como argumentos: A quantidade de <strong>retentativas</strong> (no caso<strong> 3</strong>) e o <strong>intervalo</strong> entre as retentativas (no caso<strong> 1 </strong>milissegundo). Internamente ela verifica se recebeu um <em>status code</em> <strong>503</strong> e decide até quando retentar com base nos argumentos do construtor, se você precisar de alguma lógica diferente desta, basta implementar a interface ServiceUnavailableRetryStrategy e adicionar no <em>builder.</em></p><p>O request não tem nada relacionado à retentativa <em>builtin</em>, então podemos utilizar a lib async para obter um comportamento parecido com o que configuramos acima:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2f7c2242986bbf2d92b3e72aa2423f70/href">https://medium.com/media/2f7c2242986bbf2d92b3e72aa2423f70/href</a></iframe><h4>Timeouts</h4><p>Um <em>timeout</em> mal configurado ou esquecido pode derrubar sua aplicação em um momento de instabilidade de alguma de suas dependências, por isso é importante entender como configurar e o que significam os <em>timeouts</em> de um request. No HttpClient que estamos usando com o RestTemplate temos:</p><ul><li><em>connectionRequestTimeout</em>:<em> </em>O tempo limite para aguardar por uma conexão do <em>pool</em> de conexões.</li><li><em>connectTimeout</em>: O tempo limite para estabelecer uma conexão com o host desejado.</li><li><em>socketTimeout</em>: O tempo máximo de espera para finalizar a comunicação com o host de destino.</li></ul><p>Todos esses <em>timeouts</em> são definidos em milissegundos. Para configurar, é necessário criar um RequestConfig com eles e setar no seu HttpClient:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e2fc3c232dff2da70d86ac170e3537eb/href">https://medium.com/media/e2fc3c232dff2da70d86ac170e3537eb/href</a></iframe><p>No request essa configuração é mais simples, basta setar o valor do <em>timeout</em> e ele será usado tanto para <em>connect timeout</em> quanto para <em>socket timeout</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9c324ede0bb06627c8d75174b655f37a/href">https://medium.com/media/9c324ede0bb06627c8d75174b655f37a/href</a></iframe><p>Não temos como configurar <em>connectionRequestTimeout </em>no request. O comportamento da lib ao chegar ao limite de sockets é enfileirar o <em>request</em> atual, que será executado assim que um <em>socket</em> estiver livre para isso.</p><h4>Preemptive authentication</h4><p>No contexto de integração entre sistemas é muito útil já enviar a autenticação para um <em>request</em> que o cliente sabe que é protegido. Isso economiza o tratamento do <em>challenge-response</em>, que acaba fazendo com que o mesmo <em>request</em> seja feito duas vezes, uma sem a autenticação que resulta na <em>challenge-response</em> e outro com autenticação para conseguir a real resposta do <em>request</em>.</p><p>A documentação do HttpClient sugere popular o cache de autenticação antes para enviar a autenticação preemptiva, mas com o RestTemplate não utilizamos diretamente o HttpClient, então podemos apelar para o protocolo HTTP e fazer o seguinte:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a26455fab8d55c68aa0b4830f0d7bd8c/href">https://medium.com/media/a26455fab8d55c68aa0b4830f0d7bd8c/href</a></iframe><p>Aqui utilizamos um interceptor que tem o papel de interceptar todos os <em>requests</em> que passam pelo RestTemplate e realizar alguma lógica comum, antes ou depois de sua execução. Nesse caso o BasicAuthorizationInterceptor encoda o usuário e senha recebidos e adiciona o <em>header</em> de <em>basic authentication</em> com o valor correto antes da execução do <em>request</em>.</p><p>A configuração do request em Nodejs é mais simples, podemos definir uma autenticação da seguinte forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/969d6d95f23382b3ff172234c1f3eccb/href">https://medium.com/media/969d6d95f23382b3ff172234c1f3eccb/href</a></iframe><p>A autenticação preemptiva aqui é configurada pelo atributo sendImmediately, que por padrão é true e poderia ser omitido.</p><h4>User-Agent</h4><p>Para ter uma maneira fácil de saber quem está realizando um <em>request</em> é aconselhável configurarmos sempre um User-Agent para a nossa aplicação, quando temos necessidade de rastrear e/ou simular algum problema em produção essa informação é muito útil.</p><p>No RestTemplate basta setar o User-Agent no HttpClient utilizado:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c96da13e53bd05b3e04224ae62d15fa4/href">https://medium.com/media/c96da13e53bd05b3e04224ae62d15fa4/href</a></iframe><p>No request devemos simplesmente enviar o <em>header</em> HTTP com o User-Agent:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/460867a558d6e3a4a894a2bd6ae7742b/href">https://medium.com/media/460867a558d6e3a4a894a2bd6ae7742b/href</a></iframe><h4>Logging</h4><p>É sempre interessante ter rastreabilidade dos <em>requests</em> que nossa aplicação faz, mas ao invés de logar no meio do nosso código, copiando e colando um formato de método em método, devemos centralizar essa lógica de forma que ela seja reutilizada automaticamente e que novos <em>requests</em> já tenham <em>logs</em> desde a sua criação, no RestTemplate podemos implementar um interceptor para isso:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2ec8e444698c22dbd0af78e55b005686/href">https://medium.com/media/2ec8e444698c22dbd0af78e55b005686/href</a></iframe><p>Nosso interceptor aqui loga alguns dados do request e do response, poderíamos também separá-lo em uma outra classe para torná-lo mais testável e organizar melhor o nosso código, além de usar Perf4J para calcular o tempo.</p><p>O request possui um módulo próprio para debug, para ativá-lo basta fazer o seguinte:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/84579e438b1159ac9e8d7bb393e4dc1d/href">https://medium.com/media/84579e438b1159ac9e8d7bb393e4dc1d/href</a></iframe><p>Com isso teremos um output em JSON com bastante informações sobre o <em>request</em> feito e o <em>response</em> recebido.</p><h3>Conclusão</h3><p>Temos muitos detalhes de configuração para fazer <em>requests</em> HTTP de forma otimizada, controlada, reproduzível e rastreável, espero que as informações que compilei acima sejam úteis para você, independente da linguagem em que você codifica atualmente!</p><h3>Mais Informações</h3><ol><li><a href="http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#rest-client-access">http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#rest-client-access</a></li><li><a href="https://github.com/request/request">https://github.com/request/request</a></li><li><a href="https://hc.apache.org/httpcomponents-client-4.5.x/tutorial/html/connmgmt.html#d5e374">https://hc.apache.org/httpcomponents-client-4.5.x/tutorial/html/connmgmt.html#d5e374</a></li><li><a href="https://github.com/node-modules/agentkeepalive">https://github.com/node-modules/agentkeepalive</a></li><li><a href="https://hc.apache.org/httpcomponents-client-4.5.x/tutorial/html/authentication.html">https://hc.apache.org/httpcomponents-client-4.5.x/tutorial/html/authentication.html</a></li><li><a href="https://nodejs.org/api/zlib.html">https://nodejs.org/api/zlib.html</a></li><li><a href="https://en.wikipedia.org/wiki/Domain_Name_System">https://en.wikipedia.org/wiki/Domain_Name_System</a></li><li><a href="https://github.com/request/forever-agent">https://github.com/request/forever-agent</a></li><li><a href="https://martinfowler.com/bliki/BlueGreenDeployment.html">https://martinfowler.com/bliki/BlueGreenDeployment.html</a></li><li><a href="https://hc.apache.org/httpcomponents-client-4.5.x/tutorial/html/fundamentals.html#d5e316">https://hc.apache.org/httpcomponents-client-4.5.x/tutorial/html/fundamentals.html#d5e316</a></li><li><a href="http://caolan.github.io/async/docs.html#retry">http://caolan.github.io/async/docs.html#retry</a></li><li><a href="https://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/client/config/RequestConfig.html">https://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/client/config/RequestConfig.html</a></li><li><a href="https://en.wikipedia.org/wiki/Challenge%E2%80%93response_authentication">https://en.wikipedia.org/wiki/Challenge-response_authentication</a></li><li><a href="https://github.com/request/request-debug">https://github.com/request/request-debug</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7105ccf8b56" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tech-grupozap/pensando-melhor-sobre-conex%C3%B5es-http-e7105ccf8b56">Pensando melhor sobre conexões HTTP</a> was originally published in <a href="https://medium.com/tech-grupozap">Tech@Grupo ZAP</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>