<?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 Pedro Lucena on Medium]]></title>
        <description><![CDATA[Stories by Pedro Lucena on Medium]]></description>
        <link>https://medium.com/@pedrohlucena?source=rss-feb3e5f03bec------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*kyWjKDFZz9rO4WfwBWCKtQ.jpeg</url>
            <title>Stories by Pedro Lucena on Medium</title>
            <link>https://medium.com/@pedrohlucena?source=rss-feb3e5f03bec------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 16:27:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pedrohlucena/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[Por que microsserviços?]]></title>
            <link>https://medium.com/@pedrohlucena/por-que-microsservi%C3%A7os-6773e34f8049?source=rss-feb3e5f03bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/6773e34f8049</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[scalability]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Pedro Lucena]]></dc:creator>
            <pubDate>Thu, 05 Sep 2024 00:09:10 GMT</pubDate>
            <atom:updated>2024-09-05T00:09:10.688Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/612/0*ZuhSyQLv5nhTmnQr" /><figcaption>Imagem retirada do site <a href="https://www.istockphoto.com/br/foto/lego-os-blocos-duplo-em-m%C3%A3os-de-crian%C3%A7a-gm465046820-59514324">https://www.istockphoto.com/br/foto/lego-os-blocos-duplo-em-m%C3%A3os-de-crian%C3%A7a-gm465046820-59514324</a></figcaption></figure><p>A arquitetura de microsserviços tem ganhado muita popularidade nos últimos anos, mas você já se perguntou por que utilizar essa abordagem? O que a torna tão atraente para engenheiros de software e empresas? Este artigo pretende responder a essa pergunta, explorando os benefícios dos microsserviços, passando pelos 9 atributos que compõe essa arquitetura e, por fim, destacando como ela resolve problemas inerentes às arquiteturas que a precederam, como a monolítica e a SOA.</p><h3>Alinhamento de expectativas</h3><p>Esse artigo é <strong>BEM TEÓRICO </strong>e <strong>RELATIVAMENTO LONGO</strong>. Continue lendo tendo bastante ciência disso. Até porque é meio difícil fazer um artigo mais prático sobre microsserviços né gente? Porque leva bastante tempo pra construir os serviços que o formam e é meio punk cobrir todo esse processo em um artigo só, só se for sobre deploy ou alguma coisa mais específica, mas enfim…</p><p>Dito isso, bora lá! 🔥</p><h3>Problemas das arquiteturas monolítica e SOA</h3><p>Antes de mergulharmos nos microsserviços em si, é importante entender as limitações das arquiteturas que vieram antes... Pois os pequenos serviços nasceram a fim de resolver problemas das 2 principais arquiteturas que a precederam:</p><ul><li>O <a href="https://pt.wikipedia.org/wiki/Aplica%C3%A7%C3%A3o_monol%C3%ADtica"><strong>saudoso monolitão</strong>,</a> pai de todas as arquiteturas</li><li>E a <a href="https://pt.wikipedia.org/wiki/Service-oriented_architecture"><strong>SOA (Service-oriented architecture)</strong></a></li></ul><p>A arquitetura monolítica, por exemplo, consiste em uma única aplicação onde todas as suas funcionalidades estão integradas em um único código base gigantesco, um <strong>ÚNICO PROCESSO</strong>. Embora seja simples de iniciar, com o tempo, ela se torna um pesadelo para gerência:</p><ul><li>O <strong>desenvolvimento</strong> de novas funcionalidades torna-se <strong>lento</strong>, por diversos motivos. Citando alguns deles, o código fica difícil de entender, aí é aquele inferno para modificar e testar partes específicas da aplicação. <br>Além disso, para cada subida que você for fazer, uma batelada de testes são necessários para nos certificarmos que nada quebrou. E se você não automatizou esses testes, é nesse momento que você se f***, pois testes manuais precisarão ser feitos, o que é algo moroso e menos confiável que um teste automatizado. <br>Ah! E se você abre mão disso… Você corre o risco de subir coisa errada pra produção, o seu produto perde confiabilidade.</li><li>O <strong>código</strong> se torna <strong>difícil de manter</strong>. Isso se deve a aplicações monolíticas serem muito complexas, tá cheio de regra de negócio ali, é muito difícil entender o fluxo completo que a aplicação segue e tudo isso. Essa complexidade torna mais difícil de devs corrigirem bugs, implementarem novas funcionalidades ou realizarem refatorações. <br>Além disso, esse tipo de aplicação é fortemente acoplado, então não é tão simples assim dar manutenção no código, dado que uma coisinha que você mudar pode acabar quebrando prod ou o código pode simplesmente só estar difícil de mexer.</li><li>E o <strong>deploy</strong> de novas versões passa a ser <strong>arriscado</strong>, já que qualquer mudança pode impactar todo o sistema, de novo, dada a natureza fortemente acoplada dessa arquitetura.</li></ul><p>Por outro lado, a arquitetura SOA surgiu como uma evolução, com a proposta de modularizar a aplicação em serviços independentes. Olhando assim parece bonito né? Tinha tudo pra dar certo! Mas deu errado. <br>Ela ainda enfrentava problemas como:</p><ul><li>A complexidade de comunicação entre os serviços por conta do problemático <a href="https://www.ibm.com/br-pt/topics/esb"><strong>Enterprise Service Bus (ESB</strong></a><strong>)</strong>. Definitivamente um dos principais fatores, se não o principal, por essa arquitetura ter sucumbido à ruina.</li><li>E a centralização da governança e do gerenciamento de dados, o que pode levar a gargalos e ineficiências. A governança centralizada, embora não fosse um requisito técnico para a SOA, era muito adotada, o que lesava o desenvolvimento. Muito por conta das decisões importantes (padrões de codificação, segurança, etc) serem tomadas por uma autoridade central ou pela equipe, o que reduz a autonomia e deixa as coisas mais lentas, pois sempre é necessário ficar esperando aprovações ou orientações dessa figura central.<br>E, se temos um único banco de dados, isso pode criar gargalos de desempenho caso, por exemplo, muitos serviços tentem acessar o banco ao mesmo tempo, levando a tempos de resposta mais lentos e menor escalabilidade.</li></ul><p>Pra você ter uma noção, o B.O era tanto que hoje o SOA foi praticamente extinto, não se usa mais em aplicações novas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*BmdX9t4ReBdO6kN1.gif" /></figure><p>Agora você vai pensar duas vezes antes de se candidatar pra aquela vaga que pede SOA nos requisitos, vai por mim, é bucha…</p><h3>Surgimento e benefícios da arquitetura</h3><p>Foi nesse cenário que os microsserviços surgiram! Muito como uma alternativa para resolver os problemas enfrentados nas arquiteturas que falamos anteriormente. A ideia central aqui é dividir uma aplicação em um conjunto de pequenos serviços autônomos. Cada um desses é responsável por uma funcionalidade específica do sistema, permitindo que sejam desenvolvidos, testados e deployados de forma independente.</p><p>Os benefícios dessa abordagem são muitos:</p><h4><strong>Escalabilidade</strong></h4><p>Diferentes partes da aplicação podem ser escaladas independentemente, permitindo uma melhor alocação de recursos.</p><p>Se a gente comparar a arquitetura monolítica com microsserviços teremos o seguinte:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*af_xH2y4g4vt1idz.jpg" /><figcaption>Imagem retirada do artigo <a href="https://rrajusingh.wordpress.com/microservices-vs-monolith-which-architecture-is-the-best-choice-for-your-business">https://rrajusingh.wordpress.com/microservices-vs-monolith-which-architecture-is-the-best-choice-for-your-business</a></figcaption></figure><ul><li>Monolitos, por definição, rodam em um único processo. Um processo único implica que isso roda em uma única máquina. Agora, vamos dizer que entre os vários componentes que formam esse monolito, apenas o componente A requere mais recurso computacional, seja RAM, ou CPU.<br>Acontece que, nesse caso, como a aplicação toda roda em um processo único, simplesmente não dá pra alocar mais recurso pra apenas um componente dessa aplicação. <br>Monolitos tem o provisionamento de recurso muito ineficiente, porque você vai fazer o UP de RAM e CPU pra máquina em que ele está rodando e todos os outros componentes da aplicação vão estar usando esse mesmo hardware — afinal, não tem outro jeito😂 — e o serviço que realmente demandou essa escala vai ficar apenas com uma <em>partezinha</em>🤏 dos recursos computacionais que foram provisionados, inicialmente, <strong>PRA ELE</strong>, em primeiro lugar. Pode parecer besteira, mas isso faz uma <strong>BAITA DIFERENÇA</strong>.</li><li>Agora, se a gente fala de microsserviços, cada serviço roda em um processo diferente, em uma <strong>MÁQUINA DIFERENTE</strong>. Considerando o mesmo cenário, se um serviço B precisar de scaling, a gente escala <strong>APENAS ESSE SERVIÇO</strong>. Aqui, o serviço que precisa ser escalado é, literalmente, o dono da bola…</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/0*079HKQ6_RGbOpdLE.gif" /></figure><h4><strong>Manutenção</strong></h4><p>Com serviços pequenos e isolados, o código é mais fácil de entender, modificar e testar.</p><p>Monolitos tem aquela codebase enorme, HUGE.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*qOhDFU5py1RoX6CO.gif" /></figure><p>O que faz o projeto ser mais tendencioso a se tornar legado. A aplicação é tão volátil, mais tão volátil, que você não quer mexer nela, é como se fosse uma bomba, prestes a explodir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*9wWPOJ2mF5kGQ2_d.gif" /></figure><p>Simples, se o projeto só dá pau toda vez que você mexe nele, os desenvolvedores vão ter medo de mexer num projeto assim e você pode ter certeza: eles vão evitar ao máximo encostar nesse código. Bem… É assim que os projetos se tornam legado.</p><p>Microsserviços tem uma base de código bem menor e, dada a sua natureza de automação de testes, a gente coda solto🥰</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*qhDDEKTtzNhBtaEb.gif" /></figure><h4><strong>Implantação</strong></h4><p>Novas versões de um serviço podem ser implantadas sem afetar o restante da aplicação, reduzindo o risco de deploys.</p><p>O deploy de monolitos é aquela loucura né. Fazer um deploy significa implantar <strong>A APLICAÇÃO INTEIRA</strong>, mesmo que apenas uma única mísera linha de código mude e isso é lento... E não é só por causa do tempo de build não, é por causa do processo! Lembra: monolitos são <strong>FORTEMENTE</strong> <strong>ACOPLADOS</strong>, essa única linha de código tem chance de quebrar, literalmnete, grande parte ou até mesmo toda a aplicação, logo, a cada deploy, uma batelada de testes precisam ser feitos pra assegurar a qualidade do produto, e se você abre mão disso… Você já sabe.</p><p>Falando de microsserviços, cada serviço tem o seu deploy independente. Isso significa que se apenas o código do serviço C mudar, apenas o serviço C será deployado e, dada a natureza de automação de deploy e de testes nessa arquitetura, podemos ficar tranquilos! O nosso serviço será entregue com qualidade em produção🫡 E o melhor: de forma automática.</p><h4><strong>Flexibilidade tecnológica</strong></h4><p>Cada serviço pode ser desenvolvido com a linguagem e o framework que melhor se adequam ao seu propósito, facilitando a adoção de novas tecnologias e descentralizando a governança: o time tem a autonomia pra fazer a escolha da stack ideal para o serviço, afinal, serão eles que vão coda-lo no final.</p><p>Por exemplo, poderíamos ter uma aplicação onde parte dos seus serviços usando o Node.js e parte deles usam o .NET Core:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GTYqtRQ5tE0osX2iWh9ZxQ.png" /><figcaption>Imagem retirada de uma aula do curso <a href="https://www.udemy.com/course/microservices-architecture-the-complete-guide">https://www.udemy.com/course/microservices-architecture-the-complete-guide</a></figcaption></figure><p>*Esse exemplo considera apenas 2 linguagens, mas você pode usar quantas você quiser na sua stack.</p><p>Em monolitos não dá pra fazer isso. Lembra, o processo é único e, por conta de ser só um, a linguagem também deve ser única. Aqui você está amarrado à escolha de plataforma que você fez inicialmente, se você escolheu o Node, você segura na mão do Node.js e vai até o fim… Não sendo possível escolher a melhor linguagem para cada tarefa.</p><p>Mas tem que tomar cuidado… Embora a arquitetura tenha benefícios, ela não é uma bala de prata — assim como nada na programação é — e não é sempre que você deve utiliza-la. Afinal, você não quer ter a sua aplicação em capas de artigos como essas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9t-qhNkv0UgmNLeznNK-gg.png" /><figcaption>Imagem retirada de uma aula do curso <a href="https://www.udemy.com/course/microservices-architecture-the-complete-guide">https://www.udemy.com/course/microservices-architecture-the-complete-guide</a></figcaption></figure><p>É… Osso.</p><p>Esses são alguns benefícios que essa arquitetura tem a oferecer. Vocês vão ver que, a seguir, ao falarmos sobre os 9 atributos que formam uma boa arquitetura de microsserviços, algumas coisas que falamos aqui vão se repetir, então… Vamos nessa!</p><h3>Os 9 atributos de uma BOA arquitetura de microsserviços</h3><p>Martin Fowler, um dos principais pensadores sobre arquitetura de software, destacou 9 atributos que compõem uma boa arquitetura de microsserviços. Os nomes desses atributos aqui em baixo estão em inglês de propósito, para ficarem fiéis <a href="https://martinfowler.com/articles/microservices.html"><strong>ao seu artigo</strong></a>, que eu menciono mais ao fim dessa nossa conversa. Vamos explorá-los:</p><h4>Componentization via Services</h4><p>Em vez de ter um monolito, microsserviços dividem a aplicação em componentes que são implementados e implantados de forma independente. Isso permite uma modularidade, o que sempre é uma boa ideia, pois facilita a manutenção e a evolução do sistema.</p><p>Podemos modularizar aplicações de duas principais formas: com bibliotecas e com serviços. Falando de microsserviços, é preferível que façamos essa componentização via serviços. Apesar disso, bibliotecas podem e devem ser utilizadas em cada microsserviço, como partes que o compõe, não representando a componentização no todo.</p><p>Isso faz com que cada serviço rode em seu próprio processo e a sua comunicação com ele se dê através de rede, como APIs web ou <a href="https://en.wikipedia.org/wiki/Remote_procedure_call"><strong>RPC</strong></a>. Além disso, essa modularização permite que os deploys sejam mais independentes. Então, se uma linha de código mudou no serviço A, apenas o serviço A será implantado e não a aplicação por inteiro.</p><p>Por fim, utilizar serviços força o arquiteto de software a definir muito bem uma interface para interação com aquela aplicação. Simples: se você está construindo um serviço para expor para o mundo todo usar, você naturalmente vai projetar isso com mais carinho. No todo, usar componentização por serviços torna os nossos componentes muito mais bem definidos, em comparação com a componentização via bibliotecas.</p><h4>Organized Around Business Capabilities</h4><p>Cada microsserviço é desenvolvido em torno de uma capacidade de negócio específica, o que alinha o desenvolvimento de software aos objetivos da empresa.</p><p><strong>Exemplo<br></strong>Considerando uma aplicação para a gerência de uma biblioteca, poderíamos ter:</p><ul><li>O serviço de livros</li><li>O de clientes</li><li>O de empréstimos de livros</li><li>Etc…</li></ul><p>Percebe? O que define o que é um serviço aqui é sua a capacidade de negócio na aplicação.</p><p>Esse é um ponto chave pra você traçar as bordas, os limites de um serviço de uma forma bem feita. Pois um dos principais erros e anti-patterns que tem nessa arquitetura é ter serviços que não são bem definidos. Quando você não tem a clareza de onde a responsabilidade de um serviço começa e onde ela termina, a tendência é que esse serviço, que era pra ser <em>micro</em>, acabe se inflando e, com o tempo, você acabe não com um microsserviço e sim com um mini-monolito.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/384/0*mkg2CRL_PP3tYUD0" /></figure><p>Vai falar que não tem nenhum macrosserviço aí na sua empresa?</p><h4>Products not Projects</h4><p>Em vez de pensar no desenvolvimento como um projeto com início e fim, onde o projeto termina quando o código é entregue, a abordagem de microsserviços trata cada serviço como um produto em constante evolução, sempre atendendo às necessidades do negócio.</p><p>Aqui, cada serviço é tratado como um produto e o time é dono dele e responsável pelo seu sucesso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/1*hatHtVAvGdmoHw4te4l_0A.png" /><figcaption>Imagem retirada de uma aula do curso <a href="https://www.udemy.com/course/microservices-architecture-the-complete-guide">https://www.udemy.com/course/microservices-architecture-the-complete-guide</a></figcaption></figure><p>Aqui, temos um único time coeso, onde todos tem um único objetivo em mente, alinhado entre todos: garantir o sucesso do serviço desenvolvido. Percebe que aqui é todo mundo um único time? Todos estão integrados e alinhados quanto ao objetivo que deve ser cumprido.</p><p>Isso difere da abordagem de projetos tradicionais, onde, fatalmente, alguns times podem até ter objetivos diferentes as vezes:</p><ul><li>O designer quer entregar entregar a melhor experiência possível, sem se importar tanto com o back-end do sistema</li><li>O dev quer construir o melhor código, sem se atentar tanto a experiência</li><li>E por aí vai…</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/436/1*JYAdWiY_WGkVY8pRdDKXlg.png" /><figcaption>Imagem retirada de uma aula do curso <a href="https://www.udemy.com/course/microservices-architecture-the-complete-guide">https://www.udemy.com/course/microservices-architecture-the-complete-guide</a></figcaption></figure><p>Na prática, aqui tem 4 times diferentes: o de UI, o de API, o de lógica e o de banco de dados, cada um quer uma coisa, não temos algo único aqui, como na abordagem anterior.</p><p>Em microsserviços, essa frase do Werner Voegls — CTO da Amazon — <br>é muito real:</p><blockquote>You build it, you run it</blockquote><p>Então não basta apenas entregar o serviço e sair fora, e sim acompanhar o pós-entrega, resolvendo bugs, implementando melhorias, fazendo adaptações, tudo a fim de tornar o serviço melhor para o usuário, afinal: você construiu, agora você vai rodar isso em produção.</p><h4>Smart Endpoints and Dumb Pipes</h4><p>Em microsserviços, endpoints são inteligentes. A complexidade deve estar na lógica de negócio, processamento de dados e afins. Ao passo que, as pipes (ou canais de comunicação) devem ser o mais simples possível, limitando-se única e exclusivamente ao transporte de dados.</p><p>Esse atributo alfineta de forma bem direta o ESB da SOA, um dos fortes motivos pelo declínio dessa arquitetura. Comunicação é o arroz e feijão para os microsserviços, isso não deve ser complexo. A complexidade, por sua vez, deve ficar para a camada de negócio, tanto é que, o padrão para microsserviços é expor APIs REST para interação com as suas funcionalidades, o que, em suma, é HTTP, simples. Com o tempo, surgiram outras formas de comunicação, como o <a href="https://graphql.org/"><strong>GraphQL</strong></a> e o <a href="https://grpc.io/"><strong>gRPC</strong></a>, mas o padrão, para microsserviços, é REST.</p><h4>Decentralized Governance</h4><p>Diferente da SOA, que embora não tenha isso como um requisito que a compõe, frequentemente centraliza a governança, os microsserviços promovem uma governança descentralizada, permitindo que equipes escolham as melhores ferramentas e práticas para cada um dos serviços.</p><p>Esse atributo tem uma certa relação com o <a href="#e403"><strong>Products not Projects</strong></a>, porque, dado que a equipe é inteiramente responsável pelo serviço, por quê ela não pode escolher a stack tecnológica? Fazer parte de um time de microsserviços é se sentir dono do B.O, inclusive se você fizer a escolha tecnológica errada… O problema é inteiramente seu <em>e do seu time</em>.</p><h4>Decentralized Data Management</h4><p>Esse atributo é meio contraditório tá? Definitivamente o maior entre todos os 9. Bem, ele diz que cada serviço deve gerenciar o seu próprio banco de dados, favorecendo a independência entre cada serviço, além de facilitar a escalabilidade e a resiliência do sistema.</p><p>Só que tem vezes que <strong>não dá</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*7wXdYwY7juqCqjSfLn2sdw.gif" /><figcaption>Imagem retirada do site <a href="https://makeagif.com/gif/nao-vai-dar-neto-pistola-EoQmyT">https://makeagif.com/gif/nao-vai-dar-neto-pistola-EoQmyT</a></figcaption></figure><p>Que não vai dar o que, não vai dar essa porra</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/0*en-vkstOHhX1f62a.gif" /></figure><p>Não, nesse caso realmente tem vezes que não dá mesmo.</p><p>Embora microsserviços devam ser autônomos, relacionamentos entre serviços acontecem e são extremamente comuns. Até porque é extremamente difícil você construir uma aplicação que gere valor para o cliente sem que as partes que a compõe não se conversem em nada.</p><p>Uma coisa importante sobre isso é que você, arquiteto de software, não deve insistir na ideia de que cada microsserviço deve ter um banco de dados, fazer isso vai te uma dor de cabeça com duplicação de dados que você não faz ideia. Portanto, você deve buscar outras alternativas pra resolver esse problema.</p><p>Ah! E você ter um campo em uma tabela gerenciada pelo serviço A, que referencia um dado em uma tabela pelo seu ID, gerenciada pelo serviço B não é uma dependência, muita gente confunde isso. O que define se um serviço é autônomo ou não é a resposta dessa simples pergunta:</p><p>A <strong>operação</strong> desse serviço, isto é, o seu funcionamento, <strong>depende</strong> de algum <strong>outro serviço</strong> em produção?</p><p>Se a resposta for <strong>não</strong>, esse serviço é <strong>autônomo</strong>.</p><p>Esse atributo também nos fornece <strong>flexibilidade tecnológica</strong>, só que aqui é um banco de dados. Então, podemos usar diversas bancos de dados em uma aplicação, seja Mongo, Redis, Postgres ou qualquer outro, aproveitando o melhor que cada tecnologia tem a nos oferecer para tornar a aplicação melhor.</p><h4>Infrastructure Automation</h4><p>A automação de infraestrutura, seja de testes, ou de deploy, é essencial para a eficiência da sua aplicação. Nesse sentido, ferramentas de testes automatizados como o <a href="https://www.cypress.io/"><strong>Cypress</strong></a> podem ser muito úteis, além de outras como o <a href="https://www.docker.com/"><strong>Docker</strong></a> e o <a href="https://kubernetes.io/"><strong>Kubernetes</strong></a> para automação do deploy, escalabilidade e gerenciamento de containers.</p><p>Em monolitos, os testes e o deploy são manuais, o que faz a equipe perder um tempo desgraçado nessas tarefas. Devido ao forte acoplamento dessa arquitetura, uma simples mudança no código gera bateladas e bateladas de testes, se isso não é automatizado, perderemos bastante tempo aqui. Além disso, monolitos tendem a ter deploy manual, o que retarda ainda mais o processo: fazer um deploy significa implantar aplicação <strong>INTEIRA</strong> nessa arquitetura.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*8UJ5nVE_drFPP7f7.gif" /></figure><p>O que torna a automação de deploy e testes essenciais em uma arquitetura de microsserviços. Caso você despreze esse atributo, seu projeto tem grandes probabilidades de falhar. É só pensar <a href="https://www.google.com/search?sca_esv=bd020c7529828247&amp;sxsrf=ADLYWIJJS3wNxmlZs2WrEz0lCVBjBp_00Q:1725324742569&amp;q=how+many+microservices+does+netflix+have&amp;source=lnms&amp;fbs=AEQNm0DSjjYWCybNh4Y2in02N243-OHmPxREG1BKYr-Kgpdbh-COBiIiY8Fo3IG2RaEyCjej1JUx8BX1u76p09NZAhv-A94brmpt9UaxtD-9g2ROZYT3MWjVio9zPiGLeiZtvUsTpoWg8-FHaLlVO0MpNgOGTJ0y3BiKn-T1AbIYIhAUqnuPe1xbKKwygr3MnzY8knt0ayQi-8wp_dmZWcXnf92dZQ_xgA&amp;sa=X&amp;ved=2ahUKEwjGmpzDx6WIAxV_pZUCHVsCNZ8Q0pQJegQIDRAB&amp;biw=1242&amp;bih=500&amp;dpr=1.1"><strong>no case da Netflix</strong></a>, eles tem mais de mil microsserviços, imagina, meu amigo, se tudo isso fosse testado e deployado na mão, seria um terror! E dá até pra pegar um caso mais simples, eu mesmo já trabalhei em empresas que tinham quase 30 microsserviços, testar e deployar tudo isso de forma manual é extremamente trabalhoso.</p><p>Concluindo, negligenciar esse atributo pode fazer com que você, em uma arquitetura de microsserviços, viva o cenário de deploy de um monolito, onde uma mudança pode demorar até <strong>MESES</strong> para ser disponibilizada em produção. Isso, ao passo que, utilizando pequenos serviços e com uma infraestrutura automatizada, deploys podem ser feitos literalmente a cada minuto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n1Je5OXlgGXvgOo6.gif" /></figure><h4>Design for Failure</h4><p>Como cada serviço é independente, uma falha em um serviço não deve comprometer todo o sistema. <a href="https://www.google.com/search?q=resilience+microservices+what+is+&amp;sca_esv=7d26b11aab597cbb&amp;sxsrf=ADLYWIITvR0E50Gn9xlSZpAdwcdIJjxRKw%3A1725407679730&amp;ei=v6HXZseXLOvU1sQP3N6R8QE&amp;ved=0ahUKEwiH896-_KeIAxVrqpUCHVxvJB4Q4dUDCBA&amp;uact=5&amp;oq=resilience+microservices+what+is+&amp;gs_lp=Egxnd3Mtd2l6LXNlcnAiIXJlc2lsaWVuY2UgbWljcm9zZXJ2aWNlcyB3aGF0IGlzIDIFECEYoAFIohFQdljTEHABeACQAQCYAcgBoAHhCqoBBTAuOC4xuAEDyAEA-AEBmAIJoAKGCsICChAAGLADGNYEGEfCAgYQABgWGB7CAgsQABiABBiGAxiKBcICCBAAGIAEGKIEwgIFECEYnwWYAwCIBgGQBgiSBwUxLjcuMaAHkh0&amp;sclient=gws-wiz-serp"><strong>Resiliência</strong></a> é fundamental, e para isso, estratégias como circuit breakers e retries podem ser utilizadas para lidar com falhas.</p><p>Microsserviços devem ser desenhados pensando em possíveis falhas. <br>Por exemplo, se um serviço A chama o serviço B, esse serviço que chamou precisa estar preparado para lidar com o cenário do serviço B estar down. Essa é apenas uma, entre as diversas falhas as quais um microsserviço deve estar preparado para lidar.</p><p><a href="https://medium.com/trainingcenter/design-pattern-para-microservices-circuit-breaker-f4a5b68f73d1"><strong>Circuit breakers</strong></a></p><p>O <strong>Circuit Breaker</strong> é um padrão de design usado em arquiteturas distribuídas, como a de microsserviços, para aumentar a resiliência e a estabilidade do sistema. Ele funciona de forma análoga ao <a href="https://www.margirius.com.br/blog/disjuntores-entenda-sua-importancia-e-saiba-como-funcionam/"><strong>disjuntor elétrico</strong></a>: quando um serviço dependente começa a falhar repetidamente, o Circuit Breaker interrompe temporariamente as chamadas para esse serviço:</p><ul><li>Evitando sobrecarga</li><li>E permitindo que o sistema degrade de maneira controlada.</li></ul><p>Quem diria… Física⚡</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*X5q5O_tf1c0vHsDk.gif" /></figure><p>Durante esse período, em vez de tentar acessar o serviço falho, o Circuit Breaker pode retornar respostas pré-definidas ou falhas imediatas, até que o serviço dependente demonstre estar funcionando novamente. Isso ajuda a prevenir que falhas localizadas se propaguem e causem problemas em cascata, protegendo o sistema como um todo.</p><p>Sem Circuit Breaker:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*Y_vgY5pt5cJb2y99BoVtRA.png" /><figcaption>Imagem retirada de uma aula do curso <a href="https://www.udemy.com/course/microservices-architecture-the-complete-guide">https://www.udemy.com/course/microservices-architecture-the-complete-guide</a></figcaption></figure><p>Com Circuit Breaker</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/793/1*ik4BcLGc0RPVjZqwTlfPSg.png" /><figcaption>Imagem retirada de uma aula do curso <a href="https://www.udemy.com/course/microservices-architecture-the-complete-guide">https://www.udemy.com/course/microservices-architecture-the-complete-guide</a></figcaption></figure><p><a href="https://medium.com/engineering-at-bajaj-health/building-resilient-systems-retry-pattern-in-microservices-1b857da0e0eb"><strong>Retries</strong></a></p><p>Voltando ao exemplo mencionado no começo desse atributo, caso o serviço B estivesse offline, o serviço A poderia ter uma lógica de retry, isto é, o serviço A continua tentando se conectar novamente com o serviço B, passados 15 minutos da última tentiva por exemplo. Essa lógica persiste até um limite, como por exemplo 6 retentativas de conexão e, passadas essas retentativas, a mensagem pode ficar represada em uma fila por exemplo, caso mensageria esteja sendo utilizada no sistema. Inclusive, engines de filas, como o <a href="https://aws.amazon.com/pt/sqs/"><strong>SQS</strong></a>, costumam já suportam retries por padrão…</p><h4>Evolutionary Design</h4><p>Uma arquitetura de microsserviços é projetada para <strong>evoluir com o tempo</strong>. Novos serviços podem ser adicionados, e antigos, substituídos ou atualizados, sem causar grandes impactos no sistema como um todo, lembre-se: os serviços são <strong>AUTÔNOMOS</strong>.</p><p>Ainda, caso você já tenha uma aplicação monolítica e queira migra-la para microsserviços, esse atributo também diz que essa mudança deve ser gradual. Embora, seja bem tentador quebrar todos os serviços de uma vez e sair desenvolvendo, esse não é o caminho ideal, afinal, tem um produto rodando e ele precisa evoluir pra trazer o dote 💰 pra empresa.</p><p>Por isso, é mais recomendado que comecemos pequeno, fazendo o upgrade de cada parte da aplicaçãode forma individual. Nessa abordagem, temos muito mais oportunidades de debugar problemas que possam acontecer decorrentes da modularização de um componente da nossa plataforma em um serviço.</p><p>Esse processo é um ciclo:</p><p>Implementar o microsserviço =&gt; <br>Substituir o componente de software antigo, pelo novo serviço =&gt;<br>Testar, a fim de encontrar problemas =&gt;</p><p>Esse processo deve ser repetido para todos os seus componentes da sua aplicação, até que você, enfim, tenha uma aplicação inteira baseada em microsserviços💪</p><h3>Nossa, mas tudo isso?</h3><p>É, mas raramente uma aplicação vai seguir os 9, fica tranquilo! Com isso, tem alguns desses atributos são mais importantes aqui tá? E você deve se esforçar ao máximo para segui-los. São eles:</p><ul><li><strong>Componentization:</strong> A facilidade de manutenção e deploy ao utilizar uma boa componentização é imbatível. Lembre-se: serviços ao invés de bibliotecas.</li><li><strong>Organized around business capabilities:</strong> Extremamente importante para não cairmos nos anti-patterns mencionados no artigo. É preciso definir muito bem onde um serviço começa e onde ele termina, não se deve nunca começar uma API pequena e ver onde vai parar, sem qualquer planejamento.</li><li><strong>Descentralized governance:</strong> Definitivamente um dos atributos mais populares. Permitir que o time decida qual a melhor ferramenta para aquela tarefa deixam-nos mais satisfeitos, o serviço será desenvolvido melhor por consequência e no fim quem ganha é o usuário.</li><li><strong>Descentralized data management:</strong> Não é sempre que você vai conseguir implementar, mas esse é um dos atributos mais importantes dessa arquitetura, pois torna nossos serviços mais autônomos. Lembre-se: não insista nesse atributo caso o sistema apresenta resistências à ele, pois você provavelmente estará caindo em armadilhas.</li><li><strong>Infrastructure automation:</strong> Uma arquitetura de microsserviços sem testes e deploys automatizados provavelmente resultará em um sistema lento de testar e fazer deploy, o que pode fazer o cliente questionar a real eficiência de vocês estarem usando a arquitetura. A sua infra <strong>DEVE</strong> ser automatizada.</li></ul><h3>Referências</h3><p>Quer se aprofundar <strong>AINDA MAIS</strong> nessa arquitetura? É, eu sei, ela é dahora demais. Deixo aqui algumas recomendações pra te ajudar nessa missão:</p><ul><li><a href="https://martinfowler.com/articles/microservices.html"><strong>Artigo do Martin Folwer</strong></a>: Simplesmente o primeiro artigo publicado sobre o tema, em 2014. Desde então, esse artigo se tornou um padrão para a definição de microsserviços, é como se fosse a bíblia — só que bem mais mais curta — da arquitetura de microsserviços.</li><li><a href="https://www.udemy.com/course/microservices-architecture-the-complete-guide"><strong>Curso “Microservices Architecture — The Complete Guide”</strong></a><strong>:</strong> Como eu disse, esse artigo pega apenas alguns dos pontos que eu aprendi fazendo esse curso, existem vários outros. Faz o curso, corre atrás desses outros pontos que faltam🔥 Se você gostou desse artigo, não tem erro, você vai adorar o curso😍</li></ul><h3>Conclusão</h3><p>Ao escolher uma arquitetura de microsserviços, você opta por uma solução que endereça os problemas das arquiteturas monolítica e SOA, ao mesmo tempo que oferece escalabilidade, flexibilidade, resiliência entre diversos outros benefícios. Este artigo foi escrito muito como uma espécie de “TCC” de um curso que terminei recentemente, o <a href="https://www.udemy.com/course/microservices-architecture-the-complete-guide"><strong>Microservices Architecture — The Complete Guide</strong></a>, onde pude aprofundar meus conhecimentos nessa área fascinante.</p><p>Espero que este artigo tenha lhe dado uma visão clara dos motivos pelos quais os microsserviços são uma escolha tão poderosa para o desenvolvimento moderno de software ^^.</p><h3>Bom, é isso, espero que tenha gostado! E se tiver alguma sugestão deixe aí nos comentários 💬</h3><p>Se gostou, dê 1 ou 50 claps (Só clicar 50x na 👏), ou é 1, ou é 50, não tem meio termo.</p><p><strong>Obrigado pela leitura!</strong></p><p><em>Me acompanhe por aí!</em> 😜</p><ul><li>Portfólio: <a href="https://pedrohlucena.vercel.app/">pedrohlucena.vercel.app</a></li><li>GitHub: <a href="https://github.com/pedrohlucena">@pedrohlucena</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/pedrohlucena1">@pedrohlucena1</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6773e34f8049" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como o React realmente funciona (Algoritmo de Reconciliação)]]></title>
            <link>https://medium.com/@pedrohlucena/como-o-react-realmente-funciona-algoritmo-de-reconcilia%C3%A7%C3%A3o-e427e8149a7b?source=rss-feb3e5f03bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/e427e8149a7b</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[performance-optimization]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Pedro Lucena]]></dc:creator>
            <pubDate>Sat, 24 Aug 2024 17:15:04 GMT</pubDate>
            <atom:updated>2024-08-24T17:15:04.664Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1020/0*OC2tH8D95U1TMc4l" /><figcaption>Imagem retirada do artigo <a href="https://bgr.com/science/this-is-the-first-ever-x-ray-of-a-single-atom">https://bgr.com/science/this-is-the-first-ever-x-ray-of-a-single-atom</a></figcaption></figure><p>Se você tá afim de revisar base de React e entender, de maneira mais profunda, como essa biblioteca funciona por debaixo dos panos e consegue ser tão performática, esse artigo é pra você! Motivado por não ter conseguido responder à pergunta: ”Você saberia explicar como funciona o algoritmo de reconciliação do React?”, hoje escrevo esse artigo, pra que você saiba responder à pergunta que eu não soube.</p><h3>Do que se trata esse algoritmo afinal?</h3><p>O algoritmo de reconciliação do React é o mecanismo que a biblioteca tem para determinar como as mudanças no estado de uma aplicação devem refletir na interface do usuário de forma eficiente e performática. <br>E muita atenção ao “eficiente e performática” aqui, porque quando um estado muda, em vez de toda a nossa árvore de componentes HTML ser recriada do zero, o React comparará:</p><ul><li>A nova árvore de elementos, criada e renderizada na “Virtual DOM”</li><li>Com a árvore antiga, que já está lá no browser</li></ul><p>Aplicando apenas as mudanças <strong>DE FATO NECESSÁRIAS</strong> no DOM real.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/0*L5m23pjlK4mDZwap" /><figcaption>Imagem retirada do artigo <a href="https://medium.com/@ryanbas21/react-reconciliation-7075e3f07437">https://medium.com/@ryanbas21/react-reconciliation-7075e3f07437</a></figcaption></figure><p>Se você está familiarizado com o HTTP, a ideia aqui é bem o que acontece com o <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Methods/PATCH"><strong>método PATCH</strong></a> do protocolo, no sentido de apenas serem aplicadas <strong>O QUE DE FATO MUDOU</strong> na comparação entre a DOM Virtual e a DOM real. Isso, assim como o método PATCH do Hypertext Transfer Protocol, que atualiza apenas os dados que foram enviados na requisição, no recurso a ser alterado do servidor.</p><h4>“Pera aí que eu já fiquei confuso! Virtual O QUE?”</h4><p>Virtual DOM! Calma que eu explico. A <a href="https://pt-br.legacy.reactjs.org/docs/faq-internals.html#what-is-the-virtual-dom"><strong>DOM Virtual</strong></a> é uma <strong>representação</strong> <strong>leve</strong> e <strong>em memória</strong> da árvore de elementos da DOM real. Ela permite que o React <strong>compare diferentes estados da interface</strong> de forma eficiente, identificando mudanças entre:</p><ul><li>A versão antiga</li><li>E a nova</li></ul><p>Sem qualquer necessidade de interagir diretamente com a DOM real, o que só acontece quando de fato é necessário aplicar alguma atualização. Isso <strong>reduz o custo e a complexidade </strong>das operações de atualização da interface, tornando o <strong>processo mais rápido e eficiente</strong>🐇⚡</p><p>*Você já deve ter ouvido falar que aplicações React são performáticas por natureza e elas são mesmo e, agora, você sabe o motivo.</p><p>Bora pro código! Exemplo simples de gerenciamento de estado, você já viu isso 30 mil vezes na sua vida:</p><pre>export function App() {<br>  const [count, setCount] = useState(0);<br><br>  return (<br>    &lt;div&gt;<br>      &lt;h1&gt;Contador: {count}&lt;/h1&gt;<br>      &lt;button onClick={() =&gt; setCount(count + 1)}&gt;Incrementar&lt;/button&gt;<br>    &lt;/div&gt;<br>  );<br>}</pre><p>Quando o estado count muda, o React precisa atualizar a interface para refletir esse novo estado. Mas, como ele decide o que atualizar? <br>É aqui que o algoritmo entra em ação😎</p><h3>Como o algoritmo funciona?</h3><p>O processo de reconciliação ocorre em duas fases principais:</p><ul><li>A Renderização</li><li>E o Commit.</li></ul><p><strong>1. Renderização</strong></p><p>Aqui o React “reage”, criando uma nova árvore de elementos com base nas alterações do estado. Essa nova árvore é comparada com a árvore anterior, que está lááá no browser.</p><p>Então, por exemplo:</p><pre>&lt;div&gt;<br>  &lt;h1&gt;Contador: 0&lt;/h1&gt;<br>  &lt;button&gt;Incrementar&lt;/button&gt;<br>&lt;/div&gt;</pre><p>Considera que a árvore de elementos que está no navegador é essa aqui em cima☝️</p><p>E, após uma mudança de estado, o React vai renderizar isso aqui:</p><pre>&lt;div&gt;<br>  &lt;h1&gt;Contador: 1&lt;/h1&gt;<br>  &lt;button&gt;Incrementar&lt;/button&gt;<br>&lt;/div&gt;</pre><p>Fazendo a comparação entre as duas DOMs, o React estará apto a identificar que apenas o conteúdo dentro do &lt;h1&gt; mudou.</p><p><strong>2. Commit</strong></p><p>Após a comparação, é feito o commit, isto é, o React aplica <strong>APENAS O QUE DE FATO MUDOU</strong> na DOM real, no nosso caso, o texto dentro do &lt;h1&gt;. <br>Com isso, o restante da árvore de elementos permanecerá intacta, o que torna o processo muito mais eficiente.</p><p>Se fosse pra demonstrar em um código, o que o React executa para mudar o que aparece em tela, seria “bais ou benos” isso:</p><pre>document.querySelector(&#39;h1&#39;).textContent = &#39;Contador: 1&#39;;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/0*ZltMofgSD7njiICW.gif" /></figure><h3>Componentes de Classe vs Componentes Funcionais nessa brincadeira</h3><p>O algoritmo de reconciliação lida de maneira ligeiramente diferente com componentes de classe e funcionais. Embora a lógica interna do algoritmo seja a mesma, o React lida com o estado e o ciclo de vida de maneira diferente dependendo do tipo de componente.</p><h4>Componentes de classe</h4><p>Em componentes de classe, além do que falamos, o React também vai levar em conta métodos como o <a href="https://www.geeksforgeeks.org/reactjs-shouldcomponentupdate-method/"><strong>shouldComponentUpdate()</strong></a> para otimizar o processo de reconciliação. Esse método, por exemplo, tem o poder de dizer para o React renderizar, ou não, um componente. A sua chamada no momento certo pode evitar que o processo de renderização — o qual falamos agora a pouco — comece desnecessariamente, otimizando performance✨</p><h4>Componentes funcionais</h4><p>Falando de componentes funcionais, temos o <a href="https://react.dev/reference/react/memo"><strong>memo()</strong></a>, que pode envolver esses tipos de componentes para que re-renderizações sejam evitadas enquanto as suas props não mudem, nisso, o algoritmo de reconciliação não é acionado e ganhamos eficiência. Além dele, temos o <a href="https://react.dev/reference/react/useMemo"><strong>useMemo()</strong></a>, que tem o objetivo de evitar que cálculos e computações pesadas sejam feitas de novo a cada renderização. Nele, um valor é memorizado e, enquanto as suas dependências não mudarem, o seu valor também não muda. Isso evita que o processo de geração da DOM Virtual seja mais demorado, deixando as nossas aplicações mais rápidas ainda⚡</p><p>*Esses dois métodos estão bem relacionados a performance no React, caso você se interesse a pesquisar mais sobre🤓</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/889/0*LbEVW2Vqyw7xgjN5.gif" /></figure><h3>O papel das “keys” na reconciliação</h3><p>Para de ser safado e corrige esse erro cabra…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DeV09y61FBf4hzU3.png" /><figcaption>Imagem retirada do artigo <a href="https://engineering.blackrock.com/5-common-mistakes-with-keys-in-react-b86e82020052">https://engineering.blackrock.com/5-common-mistakes-with-keys-in-react-b86e82020052</a></figcaption></figure><p>Brincadeiras a parte… A <a href="https://pt-br.legacy.reactjs.org/docs/lists-and-keys.html"><strong>key do React</strong></a> desempenha um papel crucial no processo de reconciliação, especialmente ao lidar com listas de elementos. Elas ajudam o React a identificar quais itens mudaram, foram adicionados ou removidos e, então, apenas os elementos que de fato sofreram alteração são renderizados em tela, de novo: para aumentar performance.</p><pre>function TodoList({ todos }) {<br>  return (<br>    &lt;ul&gt;<br>      {todos.map((todo) =&gt; (<br>        &lt;li key={todo.id}&gt;{todo.text}&lt;/li&gt;<br>      ))}<br>    &lt;/ul&gt;<br>  );<br>}</pre><p>Considere o exemplo, cada item da lista possui uma key única, todo.id. Falando de listas, o React olha pra essa key para determinar precisamente quais itens atualizar, evitando a renderização de toda a lista, ó:</p><h4>Como o algoritmo trata arrays</h4><p>Assim que o React encontra um array de elementos, as keys são usadas para determinar quais itens mudaram em uma remoção, ou reordenação de itens, por exemplo. Considerando que essas todos fossem passados para o componente que vimos antes:</p><pre>const todos = [<br>  { id: 1, text: &#39;Comprar leite&#39; },<br>  { id: 2, text: &#39;Lavar o carro&#39; },<br>  { id: 3, text: &#39;Estudar React&#39; }<br>];</pre><p>Se fossemos remover o item de id=2, em uma filtragem, por exemplo:</p><pre>const updatedTodos = todos.filter(todo =&gt; todo.id !== 2);</pre><p>O React consegue saber, através das keys, exatamente qual item foi removido (o de id=2), nisso, ele vai lá e ajusta a DOM de acordo, como um maestro.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/0*veLY-yhZH9pO9wg2.gif" /></figure><h3>Conclusão</h3><p>Entender o algoritmo de reconciliação é fundamental para escrever componentes mais eficientes e evitar problemas de desempenho. Saber como o React toma decisões internas pode te ajudar a otimizar sua aplicação e evitar armadilhas comuns, como renderizações desnecessárias ou mudanças inesperadas no DOM. Isso, além de fazer você codar de uma forma mais consciente do que acontece por debaixo dos panos.</p><h3>Bom, é isso, espero que tenha gostado! E se tiver alguma sugestão deixe aí nos comentários 💬</h3><p>Se gostou, dê 1 ou 50 claps (Só clicar 50x na 👏), ou é 1, ou é 50, não tem meio termo.</p><p><strong>Obrigado pela leitura!</strong></p><p><em>Me acompanhe por aí!</em> 😜</p><ul><li>Portfólio: <a href="https://pedrohlucena.vercel.app/">pedrohlucena.vercel.app</a></li><li>GitHub: <a href="https://github.com/pedrohlucena">@pedrohlucena</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/pedrohlucena1">@pedrohlucena1</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e427e8149a7b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dark Mode para a sua aplicação React com Tailwind]]></title>
            <link>https://medium.com/@pedrohlucena/dark-mode-para-a-sua-aplica%C3%A7%C3%A3o-react-com-tailwind-4d502fb0d107?source=rss-feb3e5f03bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d502fb0d107</guid>
            <category><![CDATA[dark-mode]]></category>
            <category><![CDATA[tailwind-css]]></category>
            <category><![CDATA[web-design]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[user-interface]]></category>
            <dc:creator><![CDATA[Pedro Lucena]]></dc:creator>
            <pubDate>Wed, 21 Aug 2024 02:21:52 GMT</pubDate>
            <atom:updated>2024-08-22T00:27:16.824Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/539/1*IwIOImnp3QbJ3tAePexDyg.jpeg" /><figcaption>Imagem retirada desse site: <a href="https://stock.adobe.com/br/search/images?k=farm+at+night&amp;asset_id=171071883">https://stock.adobe.com/br/search/images?k=farm+at+night&amp;asset_id=171071883</a></figcaption></figure><p>No mundo atual, a implementação de temas escuros tem se tornado cada vez mais popular entre os desenvolvedores. Oferecer uma opção de Dark Theme pode melhorar a experiência do usuário e tornar sua aplicação mais atraente. Neste artigo, vamos explorar como fazer essa implementação utilizando <a href="https://react.dev/"><strong>React</strong></a> e o <a href="https://tailwindcss.com/"><strong>Tailwind CSS</strong></a>. Passaremos por cada etapa do processo, desde a configuração até a aplicação do tema.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/0*uIrlsqKzrCyKZunp.gif" /></figure><h3>1. Configuração do ambiente ⚙️</h3><p>Antes de começarmos, você precisa garantir que seu ambiente esteja pronto para trabalhar com o React e o Tailwind. Vamos passar por essas configurações rapidinho:</p><h4>Crie um novo projeto React</h4><p>Se você ainda não tem um projeto React, crie um novo. Não usa o Create React App não… Vai de <a href="https://vitejs.dev/"><strong>Vite</strong></a>:</p><pre>npm create vite@latest</pre><h4><strong>Instale o Tailwind CSS</strong></h4><p>Instale o vento favorável:</p><pre>npm install tailwindcss --save-dev</pre><p>E inicialize-o:</p><pre>npx tailwindcss init</pre><h4><strong>Configure o </strong>framework</h4><p>Edite o arquivo tailwind.config.ts para adicionar o suporte ao modo escuro:</p><pre>import type { Config } from &#39;tailwindcss&#39;<br><br>export default {<br>  darkMode: &#39;class&#39;,<br>  content: [&quot;./src/**/*.{js,jsx,ts,tsx}&quot;],<br>  theme: {<br>    extend: {},<br>  },<br>  plugins: [],<br>  variants: {<br>    extend: {},<br>  },<br>} satisfies Config</pre><p>No seu arquivo CSS (por padrão src/index.css), adicione as diretivas do Tailwind:</p><pre>@import &quot;tailwindcss/base&quot;;<br>@import &quot;tailwindcss/components&quot;;<br>@import &quot;tailwindcss/utilities&quot;;</pre><p>E importe esse arquivo, no arquivo principal da sua aplicação. No nosso caso, o src/App.tsx:</p><pre>import &#39;./index.css&#39;<br><br>export default function App() {<br>  return (<br>    &lt;h1&gt;Hello World!&lt;/h1&gt;<br>  )<br>}</pre><p>Por fim, rode esse comando:</p><pre>npx tailwindcss -i ./src/index.css -o ./src/output.css --watch</pre><p>Para que o Tailwind escaneie os seus arquivos de template buscando por classes e builde o seu CSS.</p><p>Importe esse cara no nosso index.html:</p><pre>&lt;html lang=&quot;en&quot;&gt;<br>  &lt;head&gt;<br>    ...<br>    &lt;link href=&quot;./src/output.css&quot; rel=&quot;stylesheet&quot;&gt;<br>    &lt;title&gt;Vite + React + TS&lt;/title&gt;<br>  &lt;/head&gt;<br><br>  ...<br>&lt;/html&gt;</pre><p>E altere o seu package.json para a inclusão do código que builda o Tailwind no seu script de inicialização de desenvolvimento, da seguinte forma:</p><pre>{<br>  ...<br>  &quot;scripts&quot;: {<br>    &quot;build-tailwind&quot;: &quot;npx tailwindcss -i ./src/index.css -o ./src/output.css --watch&quot;,<br>    &quot;dev&quot;: &quot;vite &amp; npm run build-tailwind&quot;,<br>    ...<br>  },<br>  ...<br>}</pre><p>E tá pronto o sorvetinho😄</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/0*ITN7GadZzFpTTISC" /><figcaption>Imagem retirada desse post no Facebook: <a href="https://www.facebook.com/photo/?fbid=4807827739462622">https://www.facebook.com/photo/?fbid=4807827739462622</a></figcaption></figure><h3>2. Configurando o Tailwind para suporte a temas 🎨</h3><p>Nosso Tailwind já está devidamente instalado e configurado. Agora, vamos criar classes para suportar o Dark Mode.</p><h4>Defina as cores do tema escuro 🌙</h4><p>Edite o arquivo tailwind.config.ts para adicionar suas cores de tema escuro:</p><pre>...<br><br>export default {<br>  ...<br>  theme: {<br>    extend: {<br>      colors: {<br>        &#39;dark-bg&#39;: &#39;#121212&#39;,<br>        &#39;dark-text&#39;: &#39;#e0e0e0&#39;,<br>        &#39;light-bg&#39;: &#39;#ffffff&#39;,<br>        &#39;light-text&#39;: &#39;#000000&#39;,<br>      },<br>    },<br>  },<br>  ...<br>} satisfies Config</pre><p>Aposto um <a href="https://chiquinho.com.br/"><strong>Chiquinho</strong></a> que você não sabe o que o operador <a href="https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-9.html#the-satisfies-operator"><strong>satisfies</strong></a> do Typescript faz… Bem, ele permite que você assegure que um objeto está em conformidade com um determinado tipo ou interface, ao mesmo tempo em que preserva a inferência de tipos. É útil quando você quer garantir que um valor corresponde a um tipo, mas também quer que o TS infira o tipo mais específico possível.</p><h4><strong>Adicione estilos condicionais</strong></h4><p>No seu CSS, defina estilos que serão aplicados quando o tema escuro estiver ativado. Vamos fazer isso no arquivo App.css:</p><pre>.dark .bg-dark-bg {<br>  background-color: theme(&#39;colors.dark-bg&#39;);<br>}<br><br>.dark .text-dark-text {<br>  color: theme(&#39;colors.dark-text&#39;);<br>}<br><br>.bg-light-bg {<br>  background-color: theme(&#39;colors.light-bg&#39;);<br>}<br><br>.text-light-text {<br>  color: theme(&#39;colors.light-text&#39;);<br>}</pre><h3>3. Criando o componente de alternância de tema 🔄</h3><p>Agora, vamos criar um componente simples para alternar entre o tema claro e escuro. Pra nossa facilidade, não sofreremos tanto quanto o rapaz desse meme:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*0ZeY1hQTB9Er7ki3.gif" /></figure><p>Que eu tenho certeza que você conhece…</p><ol><li>Crie um arquivo ThemeToggle.ts no diretório src/components e adicione o seguinte o seguinte conteúdo ao arquivo:</li></ol><pre>import { useEffect, useState } from &#39;react&#39;;<br><br>export function ThemeToggle()  {<br>  const [theme, setTheme] = useState(&#39;light&#39;);<br><br>  const toggleTheme = () =&gt; {<br>    const newTheme = theme === &#39;dark&#39; ? &#39;light&#39; : &#39;dark&#39;;<br><br>    localStorage.setItem(&#39;@dark-mode-react-tailwind:theme-1.0.0&#39;, newTheme);<br>    setTheme(newTheme);<br><br>    document.documentElement.classList.toggle(&#39;dark&#39;, newTheme === &#39;dark&#39;);<br>  };<br><br>  useEffect(() =&gt; {<br>    const themeFromLocalStorage = <br>      localStorage.getItem(&#39;@dark-mode-react-tailwind:theme-1.0.0&#39;);<br><br>    if (themeFromLocalStorage) {<br>      setTheme(themeFromLocalStorage);<br>      document.documentElement.classList.toggle(&#39;dark&#39;, themeFromLocalStorage === &#39;dark&#39;);<br>    }<br>  }, []);<br><br>  return (<br>    &lt;button className=&quot;p-2 bg-gray-200 dark:bg-gray-700 rounded&quot; onClick={toggleTheme}&gt;<br>      {theme === &#39;light&#39; &amp;&amp; &#39;🌞 Light Mode&#39;}<br>      {theme === &#39;dark&#39; &amp;&amp; &#39;🌙 Dark Mode&#39;}<br>    &lt;/button&gt;<br>  );<br>};</pre><p>Vamos analisar esse código considerando dois cenários:</p><p><strong>O usuário mudou de tema</strong></p><pre>const toggleTheme = () =&gt; {<br>  const newTheme = theme === &#39;dark&#39; ? &#39;light&#39; : &#39;dark&#39;;<br><br>  localStorage.setItem(&#39;@dark-mode-react-tailwind:theme-1.0.0&#39;, newTheme);<br>  setTheme(newTheme);<br><br>  document.documentElement.classList.toggle(&#39;dark&#39;, newTheme === &#39;dark&#39;);<br>};</pre><ol><li>Quando o usuário quiser mudar de tema, verificamos no estado theme para qual tema ele quer mudar, seja o Dark🌙, ou o Light🌞.</li><li>Feito isso, salvamos o tema que o usuário prefere no <a href="https://developer.mozilla.org/pt-BR/docs/Web/API/Window/localStorage"><strong>localStorage</strong></a>. Escolhi-o como o armazenamento para esse artigo, mas existem <a href="https://chatgpt.com/share/990e32e2-c9e7-4aa9-b413-dcfdf9a8cfac"><strong>outras formas</strong></a> de armazenar essa informação, sendo possível guarda-la até em um banco de dados😳.<br>Percebe que o nome do nosso item no localStorage é todo diferentão (@dark-mode-react-tailwind:theme-1.0.0), ele se acha… Caso você não esteja entendendo muito bem o que tá acontecendo aqui, pesquise algo como “localStorage items versioning” no Google ou ChatGPT que você terá bons resultados.</li><li>E, logo em seguida, mudamos o tema de preferência do usuário em memória (no caso, no nosso estado theme).</li><li>E por fim, a grande sacada, essa linha de código:<br>document.documentElement.classList.toggle(&#39;dark&#39;, <br>newTheme === &#39;dark&#39;)<br>A chamada da função <a href="https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList/toggle"><strong>toggle()</strong></a> aqui serve para adicionar a classe “dark” ao elemento &lt;html&gt;, no toooopo da nossa árvore de elementos HTML:</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/563/1*gEGfpjmhTu5zc_UqowEp6g.png" /></figure><p>Aí, o que acontece uma vez que o usuário troque de tema, é:<br>- Caso o novo tema seja “dark”, significa que devemos inserir a classe “dark” ao nosso elemento &lt;html&gt;, nisso, a função toggle() fará essa adição.<br>- Porém, caso o novo tema seja “light”, significa que a classe “dark” já está no nosso componente &lt;html&gt; e, portanto, ela deverá ser retirada, coisa que a função toggle() se incumbirá de fazer…</p><p>Uma vez que a classe “dark” esteja setada no nosso elemento &lt;html&gt;, todas aquelas estilizações que havíamos definido anteriormente que <strong>CONTINHAM</strong> .dark como “prefixo” ganham prioridade na <a href="https://www.w3schools.com/css/css_specificity.asp"><strong>CSS Specificity</strong></a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LMPj2eHoG_6XOXR-FyjQqw.png" /></figure><p>Tornando o nosso tema negro⚫ Vai Corinthians!</p><p>Ao passo que, quando essa classe não estiver setada, as estilizações que <strong>NÃO CONTÉM</strong> a classe “dark” ganharão prioridade, tornando o nosso tema branco. O exemplo considera estilizações personalizadas, com arquivos css a parte, mas o mesmo valeria para estilizações que utilizassem apenas as classes utilitárias do nosso saudoso Tailwind.</p><ul><li>Inclusive, será assim que você definirá novos estilos personalizados em desenvolvimentos futuros na sua aplicação multi-tema, tudo que for referente ao tema Dark você coloca o seletor “.dark” antes dos demais seletores da sua estilização, para a seleção da classe “dark” em primeiro lugar.</li></ul><p>Ah! Também é possível definir uma classe customizada para determinar a utilização do tema escuro com darkMode=[&quot;class&quot;, &quot;dark-class&quot;]. Dessa forma, a mesma lógica que falamos se mantém, mas ao invés da classe determinante do tema Dark ser a “.dark”, é uma definida por nós, sendo, no nosso exemplo, a classe “dark-class”.</p><p>Com isso, passamos pela função toggleTheme() completa✅</p><p><strong>O usuário carregou a aplicação</strong></p><p>Agora, o segundo cenário. Beleza! Uma vez com o nosso tema salvo no localStorage, precisamos recupera-lo quando o usuário carregar a aplicação. No código, fazemos isso através do hook <a href="https://react.dev/reference/react/useEffect"><strong>useEffect()</strong></a>:</p><pre>useEffect(() =&gt; {<br>  const themeFromLocalStorage = <br>    localStorage.getItem(&#39;@dark-mode-react-tailwind:theme-1.0.0&#39;);<br><br>  if (themeFromLocalStorage) {<br>    setTheme(themeFromLocalStorage);<br>    document.documentElement.classList.toggle(&#39;dark&#39;, themeFromLocalStorage === &#39;dark&#39;);<br>  }<br>}, []);</pre><ol><li>Recuperamos o tema de preferência do usuário do localStorage, com localStorage.getItem()</li><li>Caso ainda não haja preferência do usuário por um determinado tema, não fazemos nada…</li><li>Caso haja, setamos o tema preferido do usuário em memória, no nosso estado theme</li><li>E chamamos a nossa função toggle(), que seguirá a mesma lógica descrita no <a href="#7f04"><strong>passo 4 do cenário anterior</strong></a>.</li></ol><p><strong>Use o componente no App</strong></p><p>Importe e use o &lt;ThemeToggle /&gt; no seu componente principal App.tsx:</p><pre>import &#39;./index.css&#39;<br>import &#39;./App.css&#39;;<br>import { ThemeToggle } from &#39;./components/ThemeToggle&#39;;<br><br>export default function App() {<br>  return (<br>    &lt;div className=&quot;bg-light-bg text-light-text dark:bg-dark-bg dark:text-dark-text min-h-screen flex items-center justify-center gap-4&quot;&gt;<br>      &lt;ThemeToggle /&gt;<br><br>      &lt;h1 className=&quot;text-3xl&quot;&gt;Hello, Dark Mode!&lt;/h1&gt;<br>    &lt;/div&gt;<br>  );<br>};</pre><h3>4. Aplicando o tema escuro nas suas estilizações</h3><p>Certifique-se de aplicar as classes condicionais apropriadas em seus componentes para garantir que o tema escuro seja aplicado corretamente.</p><p>Use as classes dark:bg-dark-bg e dark:text-dark-text em seus componentes para garantir que o tema escuro seja aplicado:</p><pre>&lt;div className=&quot;bg-light-bg text-light-text dark:bg-dark-bg dark:text-dark-text&quot;&gt;<br>  {/* Conteúdo */}<br>&lt;/div&gt;</pre><h3>5. Testando a implementação</h3><p>Depois de configurar tudo, inicie seu aplicativo React e verifique se o tema escuro está funcionando corretamente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0rOeqe8jEmZL6J5LvCx1bw.gif" /></figure><p>Alterne entre os temas utilizando o toggle e garanta que todos os elementos estejam estilizados conforme esperado. Além disso, recarregue a página e veja se o tema escolhido foi mantido no pós-refresh.</p><h3>Determinando o tema pelas preferências do sistema do usuário</h3><p>Nessa abordagem, o Tailwind já se encarrega de aplicar o tema escuro automaticamente, com base nas preferências de sistema operacional do usuário. Isso significa que, se o sistema do usuário estiver configurado para usar o modo escuro, o vento favorável ajustará o tema do site sem necessidade de uma intervenção do usuário.</p><p>Para ativar essa opção, basta configurar o Tailwind da seguinte maneira:</p><pre>...<br><br>export default {<br>  ...,<br>  darkMode: &#39;media&#39;<br>} satisfies Config</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/259/0*8oTRj2bjpY-S5hb8" /></figure><p>“E só.”</p><p>Será que vocês vão pegar essa referência?</p><p>E é isso! O código que passamos juntos ao longo do artigo está nesse repositório do Github:</p><p><a href="https://github.com/pedrohlucena/blog/tree/master/dark_mode_react_tailwind/app">blog/dark_mode_react_tailwind/app at master · pedrohlucena/blog</a></p><h3>Pense bem antes de implementar… 🚨</h3><p>Uma vez terminada a implementação, parabéns! Você está amaldiçoado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/502/0*dthsysiIFPg6iYk7" /></figure><p>Agora, para cada nova feature que vocês tiverem que implementar:</p><ul><li>A(o) designer vai ter que protipar a funcionalidade, tanto no tema escuro, quanto no tema claro.</li><li>Além do que você vai ter que codar com essas classes dark:blablabla e bg-dark-blablabla, o que, convenhamos, pode ser um porre…</li><li>Além do que, no copy review, a(o) designer vai ter que ver se a tela está certa em dois temas distintos</li></ul><p>Isso requere <strong>MAIS ESFORÇO</strong> para implementação e, portanto, <strong>MAIS DINHEIRO </strong>desprendido💵 Porque a estilização precisa ser feita duas vezes e, dependendo do porte da sua empresa isso é algo que você não quer. <br>Aqui eu to falando com, principalmente, quem trabalha em startup. Então, esteja no momento certo para implementar o multi-tema e segura a bucha depois.</p><h3>Conclusão</h3><p>Neste artigo, exploramos como implementar um Dark Theme em um aplicativo React utilizando Tailwind CSS. Passamos por todos os passos necessários, desde a configuração do ambiente até a criação de um componente para alternar temas. Como o Tailwind é lindo, foi bem tranquilo né? Agora você pode oferecer uma experiência de usuário mais agradável com a opção de tema escuro em sua aplicação.</p><h3>Bom, é isso, espero que tenha gostado! E se tiver alguma sugestão deixe aí nos comentários 💬</h3><p>Se gostou, dê 1 ou 50 claps (Só clicar 50x na 👏), ou é 1, ou é 50, não tem meio termo.</p><p><strong>Obrigado pela leitura!</strong></p><p><em>Me acompanhe por aí!</em> 😜</p><ul><li>Portfólio: <a href="https://pedrohlucena.vercel.app/">pedrohlucena.vercel.app</a></li><li>GitHub: <a href="https://github.com/pedrohlucena">@pedrohlucena</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/pedrohlucena1">@pedrohlucena1</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d502fb0d107" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ataques mais comuns em aplicações front-end (e como se proteger à eles)]]></title>
            <link>https://medium.com/@pedrohlucena/ataques-mais-comuns-em-aplica%C3%A7%C3%B5es-front-end-e-como-se-proteger-%C3%A0-eles-d9cd19da44d9?source=rss-feb3e5f03bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9cd19da44d9</guid>
            <category><![CDATA[secure-coding]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Pedro Lucena]]></dc:creator>
            <pubDate>Sun, 11 Aug 2024 00:01:40 GMT</pubDate>
            <atom:updated>2024-08-11T00:01:40.015Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/698/0*q60wC0Denu-4QZ2E.png" /><figcaption>Imagem retirada do artigo <a href="https://www.business2community.com/cybersecurity/prepare-information-security-threats-2018-01998545">https://www.business2community.com/cybersecurity/prepare-information-security-threats-2018-01998545</a></figcaption></figure><p>Aplicações front-end são frequentemente alvo de diversos tipos de ataques, que podem comprometer a segurança dos dados e a integridade do sistema. Neste artigo, exploraremos alguns dos ataques mais comuns no mundo das telas e em como você pode proteger a sua aplicação de gente maldosa. Eu e você nesse artigo estamos “pique assim”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*lkXd8hTF0PRnjvqu.gif" /></figure><h3>Mas afinal… Por que eles fazem isso? 🤔</h3><p>Se começa do começo! Por que esses ataques acontecem? Qual a motivação desses hackers para cometer esses crimes, afinal?</p><p>A maioria dos ataques aos quais passaremos nesse artigo são motivados por diversos fatores. Os hackers podem estar em busca de roubo de dados pessoais e financeiros para vender no mercado negro ou cometer fraudes; podem querer causar danos à reputação das empresas ou extorqui-las por resgates; ou simplesmente buscam ganhar notoriedade e reconhecimento na comunidade hacker, sim, isso existe.</p><p>Roubar dados sensíveis, como informações de login, detalhes bancários ou dados pessoais pode ser extremamente lucrativo, além de fornecer os meios para uma série de outros crimes cibernéticos, como roubo de identidade e espionagem. Em outros casos, a motivação pode ser política ou ideológica, com ataques direcionados a organizações específicas para promover uma causa ou mensagem.</p><p>Não sei se você se lembra da notícia que saiu a um tempo atrás de <a href="https://www.uol.com.br/carros/noticias/redacao/2024/07/19/crime-sem-vitimas-brasileira-falsificou-2-mil-contas-da-uber-nos-eua.htm"><strong>uma mulher que falsificou 2 mil contas da Uber nos Estados Unidos</strong></a>. O crime consistiu na emissão de contas na Uber para imigrantes, utilizando a identidade de outras pessoas, o que só foi possível comprando dados na dark web. Nem te conto como esses dados foram parar lá…</p><h3>Cross-Site Scripting (XSS)</h3><p>Era “prank”, eu te conto sim… Agora que entendemos melhor sobre as motivações desses hackers, vamos ao primeiro ataque: o XSS.</p><h4>O que é XSS?</h4><p><strong>Cross-Site Scripting (XSS)</strong> é uma vulnerabilidade que permite que um atacante injete scripts maliciosos em páginas web vistas por outros usuários, através de, por exemplo, código Javascript third-party como o React, o Vue, o jQuery, o Google Analytics, etc, inserido no seu site.</p><p>Esses scripts podem roubar informações confidenciais, como cookies de sessão desprotegidos, ou até realizar ações em nome do usuário.</p><p>Uma coisa que eu vejo muito acontecer é o pessoal guardar access_token de acesso a API no localStorage… Gente, <strong>NÃO PODE</strong>🚫 <br>Informações guardadas no localStorage são extremamente fáceis de serem recuperadas com Javascript, um simples localStorage.getItem() malicioso inserido no seu site e puf! Informação roubada💨</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/971/0*zSepG5qBgwPeSNAO.gif" /></figure><h4>Como se proteger?</h4><ul><li><strong>Validação e escapamento de dados:</strong> <br>Antes de fazer a renderização de um <strong>dado de entrada do usuário, </strong>se atente a:<br>- <strong>Valida-los:</strong> Então, se um campo é pretendido a receber apenas números, coloca essa trava, isso pode te poupar uma dor de cabeça…<br>- <strong>E escapa-los:</strong> O escapamento é o processo de transformar caracteres especiais em entidades HTML, como, por exemplo, as aspas duplas <br>(&quot;) se transformarem em &amp;quot;. Dessa forma, caracteres especiais como esses serão tratados como texto e não como código executável. Isso pode ser feito tanto do lado do cliente, quanto do lado do servidor.<br><br>São apenas os dados inputados pelo usuário que devemos nos preocupar mesmo, porque é através deles que o hacker entra em contato com a nossa aplicação.</li><li><strong>Content Security Policy (CSP):</strong> Implemente uma política de segurança de conteúdo (Content Security Policy, ou CSP) para limitar as origens de scripts executáveis, autorizando a execução apenas daqueles que vem de fontes confiáveis.</li><li><strong>Sanitização de HTML:</strong> Utilize bibliotecas de sanitização para limpar o HTML de entradas maliciosas🧹 Um exemplo desse tipo de biblioteca é o <a href="https://github.com/cure53/DOMPurify"><strong>DOMPurify</strong></a> para o React, por exemplo.</li></ul><h3>Cross-Site Request Forgery (CSRF)</h3><h4>O que é CSRF?</h4><p><strong>CSRF</strong> é um ataque que força um usuário autenticado a executar ações indesejadas em uma aplicação web na qual ele está autenticado. Isso pode levar a ações não autorizadas, como:</p><ul><li>Mudanças de senha ou e-mail🔐</li><li>Ou transferências de fundos💵</li></ul><p>O usuário fica “pique” assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*jL040XXLSxhNfdYs.gif" /></figure><p>Entendendo nada…</p><h4>Como se proteger?</h4><ul><li><strong>Tokens CSRF:</strong> Os <a href="https://stackoverflow.com/questions/5207160/what-is-a-csrf-token-what-is-its-importance-and-how-does-it-work"><strong>tokens CSRF</strong></a> são, em suma, valores únicos (e secretos) gerados pelo servidor e incluídos em formulários e requisições que precisam ser protegidos contra esse tipo de ataque. O grande objetivo aqui é garantir, requisição a requisição, se a solicitação que está sendo feita ao servidor é originária de um usuário autenticado e não de um atacante tentando explorar uma vulnerabilidade CSRF.<br>E, embora eles sirvam pra verificar se a requisição vem de um usuário autenticado, eles <strong>são diferentes de tokens de autenticação</strong>, justamente por terem um propósito diferente desses tokens, além de cada um deles terem suas próprias particularidades.</li><li><strong>Verificação do Referer:</strong> O Referer é um cabeçalho do HTTP que informa a URL que fez aquela requisição, a origem daquela solicitação. Fazer uma verificação em cima desse header pode ser importante para a garantia de que as requisições no seu site estão sendo feitas apenas de fontes confiáveis.</li><li><strong>Cookies SameSite:</strong> Configure os seus cookies com a flag <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Cookies#cookies_samesite_experimental"><strong>SameSite</strong></a>, dessa forma, eles não serão enviados em requisições cross-site.<br>*O artigo <a href="https://angularindepth.com/posts/1382/localstorage-vs-cookies"><strong>LocalStorage vs. Cookies: All You Need to Know About Storing JWT Tokens Securely in the Front-End</strong></a><strong> </strong>apresenta uma interessante solução para o armazenamento de tokens JWT no armazenamento do browser, utilizando os cookies SameSite como parte da sua solução, recomendo <strong>PRA CARAMBA</strong> essa leitura.</li></ul><h3>Clickjacking</h3><h4>O que é Clickjacking?</h4><p><strong>Clickjacking</strong> é uma técnica onde um usuário é induzido a clicar em algo diferente do que ele pensa, possivelmente revelando informações confidenciais ou tomando ações indesejadas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*MMFNzvmdULRBhv91.gif" /></figure><p>O que acontece aqui é que o atacante pode criar um site malicioso que é uma cópia do seu, através da inserção de um iframe, da sua aplicação, nesse site cópia. É bem a ideia daquele meme do homem aranha:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qkgKHNtgKkst5fLd.jpg" /></figure><p>E nisso, ele vai e coloca uma camada transparente, ou semi transparente, na frente desse iframe que contém a sua aplicação clonada. Dessa forma, quando o usuário estiver interagindo com esse site malicioso, ele tem a impressão que está interagindo com o seu site verídico e, nisso, ele pode acabar realizando ações indesejadas.</p><h4>Como se proteger?</h4><ul><li><strong>X-Frame-Options:</strong> Use o cabeçalho HTTP de resposta X-Frame-Options para impedir que sua página seja carregada em um frame. Pra esse cabeçalho, temos alguns valores principais:<br>- <strong>DENY:</strong> Este valor impede <strong>COMPLETAMENTE</strong> que a sua página seja exibida em um iframe, independentemente de onde o iframe esteja sendo carregado.<br>- <strong>SAMEORIGIN:</strong> Este valor já permite que a página seja inserida em um iframe, mas apenas se o iframe estiver sendo carregado de dentro do mesmo domínio da aplicação a ser exibida no frame.<br>- <strong>ALLOW-FROM uri:</strong> Este valor permite que a página seja exibida em um iframe apenas caso ele esteja sendo carregado de um URI específico.</li><li><strong>Content Security Policy (CSP):</strong> O CSP entra em ação de novo! Você pode utiliza-lo para prevenir que sua aplicação seja incorporada em iframes de domínios não autorizados.</li></ul><h3>Man-in-the-Middle (MitM)</h3><h4>O que é MitM?</h4><p><strong>Man-in-the-Middle (MitM)</strong> é um ataque onde o atacante intercepta e possivelmente altera a comunicação entre dois sistemas. Isso pode comprometer a confidencialidade e integridade dos dados que estão sendo transmitidos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*XZ_oevKM6P0S1M40.gif" /></figure><h4>Como se proteger?</h4><ul><li><strong>HTTPS:</strong> Sempre utilize o HTTPS para garantir que a comunicação entre o cliente e o servidor seja criptografada. Chamadas “HTTP”, sem o “S”, transmitem os dados da requisição como um simples texto plano, sem qualquer tipo criptografia🙀 O que favorece a leitura desse atacante aos dados transmitidos, na interceptação.</li><li><strong>Certificados TLS:</strong> Utilize certificados TLS válidos e mantenha-os atualizados. Esse item está bem relacionado ao anterior, pois é o certificado TLS — um documento digital — que autentica a identidade de um site e permite que a conexão entre o browser e o servidor seja criptograda e segura✨ Esses certificados vencem em um período de 1–2 anos, por isso é importante mantê-los sempre atualizados para que a confiança dos usuários no seu site seja preservada.</li><li><strong>HSTS:</strong> Implemente HTTP Strict Transport Security (HSTS) para garantir que os navegadores só se comuniquem via HTTPS. Isso a gente implementa do lado do servidor, na prática, é como se ele falasse:<br>“Ó, você só vai se comunicar comigo via HTTPS, nada de HTTP”<br>Como se o seu ou a sua namorada(o) falasse que só faz se vocês usarem aquela coisa que criança confunde com bala👀 A ideia é a mesma…<br>*Desculpa a comparação gente, mas é bem isso😂 Agora você nunca mais vai esquecer o que é HSTS, de nada😉</li></ul><h3>Injection (SQL, Command Injection)</h3><h4>O que é Injection?</h4><p><strong>Injeções</strong> referem-se a um tipo de ataque onde um invasor consegue “injetar” 💉 ou inserir código malicioso em uma aplicação, fazendo com que ela execute comandos ou consultas indesejadas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*UUjTFjP5HIOVY_7O.gif" /></figure><p>Esses ataques geralmente ocorrem quando uma aplicação aceita dados de entrada do usuário sem uma validação adequada em comandos ou consultas executadas por um intérprete (um banco de dados ou um shell de sistema operacional e.g). Como consequência, podemos ter execuções não autorizadas no servidor ou a possível exposição de dados.</p><h4>Como se proteger?</h4><ul><li><strong>Prepared Statements:</strong> Utilize consultas parametrizadas. Se você utilizar um ORM, como o Prisma ou o Sequelize, você nem vai precisar se preocupar com isso. Pode reparar: os comandos SQL logados no terminal quando você usa ferramentas assim sempre são parametrizados, por quê será né?</li><li><strong>Validação e Sanitização:</strong> Valide e sanitize entradas do usuário antes de utilizá-las em comandos do sistema. Aí é bem na ideia do que a gente falou na parte de XSS. Falando do Cross-Site Scripting, sanitizamos e fazemos a validação pra colocar HTML no browser, trazendo isso para o Injection, fazemos isso pra passar um dado inputado pelo usuário para uma query no banco de dados, por exemplo.</li><li><strong>ORMs:</strong> Os ORMs (Object-Relational Mappers) são ferramentas que facilitam a interação de uma aplicação e um banco de dados. Ao invés de precisarmos escrever consultas SQL de forma direta, manipulamos objetos e o ORM é quem escreve as consultas pra gente, show né?<br>Ao utiliza-los, eles já vão abstrair boa parte dos aspectos relacionados à prevenção de SQL Injection para nós.</li></ul><h3>Outras Ameaças</h3><p>Além dos ataques aqui mencionados, há outras ameaças a serem consideradas, como ataques de <strong>DoS (Denial of Service)</strong>, <strong>Remote Code Execution (RCE)</strong>, <strong>Directory Traversal</strong>, e <strong>Data Exposure</strong>. Cada um desses tem suas próprias características e métodos de mitigação, que aí vocês conseguem estudar e aplicar conforme a necessidade.</p><h3>Conclusão</h3><p>Proteger sua aplicação front-end contra ataques é um passo crucial para garantir a segurança dos seus usuários e a integridade do seu sistema. Implementar as práticas mencionadas acima pode ajudar a mitigar os riscos e fortalecer a segurança da sua aplicação💪🔒</p><p>Espero que esse artigo tenha te ajudado a codar de forma mais consciente…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/549/0*cQbQ9y43ybCZBIa_.jpg" /></figure><h3>Bom, é isso, espero que tenha gostado! E se tiver alguma sugestão deixe aí nos comentários 💬</h3><p>Se gostou, dê 1 ou 50 claps (Só clicar 50x na 👏), ou é 1, ou é 50, não tem meio termo.</p><p><strong>Obrigado pela leitura!</strong></p><p><em>Me acompanhe por aí!</em> 😜</p><ul><li>Portfólio: <a href="https://pedrohlucena.vercel.app/">pedrohlucena.vercel.app</a></li><li>GitHub: <a href="https://github.com/pedrohlucena">@pedrohlucena</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/pedrohlucena1">@pedrohlucena1</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9cd19da44d9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Internacionalização de aplicações com i18n (Tradução manual)]]></title>
            <link>https://medium.com/@pedrohlucena/internacionaliza%C3%A7%C3%A3o-de-aplica%C3%A7%C3%B5es-com-i18n-tradu%C3%A7%C3%A3o-manual-7d9272bf16c2?source=rss-feb3e5f03bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d9272bf16c2</guid>
            <category><![CDATA[i18n]]></category>
            <category><![CDATA[tradução-de-aplicações]]></category>
            <category><![CDATA[internacionalização]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[desenvolvimento-web]]></category>
            <dc:creator><![CDATA[Pedro Lucena]]></dc:creator>
            <pubDate>Sun, 21 Jul 2024 14:16:05 GMT</pubDate>
            <atom:updated>2024-07-21T14:16:05.129Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4zCWQcZVMkb6mhTf.jpg" /><figcaption>Imagem retirada desse artigo: <a href="https://phrase.com/blog/posts/i18n-a-simple-definition/">https://phrase.com/blog/posts/i18n-a-simple-definition</a></figcaption></figure><p>A internacionalização (i18n) é um aspecto crucial no desenvolvimento de aplicações que buscam alcançar um público global. Neste artigo, exploraremos como internacionalizar aplicações React usando a biblioteca react-i18next. Apesar do tutorial focar em React, a abordagem pode sim ser adaptada para outras bibliotecas e frameworks, pois a ideia central aqui é salvar o conteúdo para cada idioma da sua aplicação em uma estrutura JSON e referenciar essas línguas conforme a escolha do usuário.</p><h3>O que é i18n?</h3><p>i18n é a abreviação de “internationalization”, internacionalização, em português, onde o número 18 refere-se ao número de letras entre o <br>“i” e o “n”. Internacionalização é o processo de projetar uma aplicação para que ela possa ser facilmente adaptada a vários idiomas e regiões, sem a necessidade de reescrever o código. Isso inclui não apenas a tradução de textos, mas também a adaptação de formatos de data, moeda, entre outras especificidades culturais.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/260/0*1R5P7e8cojG7J7mk.gif" /></figure><h3>As soluções 💡</h3><p>Existem duas abordagens principais para internacionalizar uma aplicação:</p><h4>Tradução manual 👐🏻</h4><p>Nesta abordagem, você traduz manualmente o conteúdo da sua aplicação para diferentes línguas e as referencia conforme a escolha do usuário.</p><p><strong>Prós:</strong></p><ul><li>Voce tem um <strong>controle maior</strong> sobre a qualidade e precisão das traduções.</li><li>E a possibilidade de <strong>personalizar as traduções</strong> de acordo com o contexto específico da aplicação.</li></ul><p><strong>Contras:</strong></p><ul><li><strong>Escalabilidade limitada</strong>, especialmente para aplicações grandes que queiram oferecer suporte a muitos idiomas.</li><li>Necessidade de <strong>atualizações manuais</strong> a cada alteração no conteúdo.</li></ul><h4>Tradução automática 🤖</h4><p>Nesta abordagem, a tradução é feita por uma ferramenta terceirizada, como o Google Translate ou o Microsoft Translator. Então, você não precisa se preocupar em traduzir o conteúdo da sua aplicação para cada língua que você queira oferecer suporte.</p><p><strong>Prós:</strong></p><ul><li>Implementação rápida e fácil.</li><li>Suporte imediato a muitos idiomas.</li></ul><p><strong>Contras:</strong></p><ul><li>As traduções podem não ser precisas ou contextualmente corretas.</li><li><strong>Dependência de serviços externos</strong>, o que pode implicar em custos adicionais e questões de privacidade.</li></ul><h3>Implementação com o react-i18next</h3><p>Vamos focar na implementação da tradução manual. Pra isso, faremos uso da biblioteca <a href="https://www.npmjs.com/package/react-i18next"><strong>react-i18next</strong></a>, que tem um peso médio-pesado (316 kB) na data que eu estou escrevendo esse artigo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/141/1*h9LtUExa1pNnEky29ru67A.png" /></figure><p>Tendo um tamanho similar até mesmo ao core do próprio <a href="https://www.npmjs.com/package/react-dom"><strong>react</strong></a>.</p><p>Caso você seja do time anti-bibliotecas, é possível criar um JSON com os conteúdos da sua aplicação, nos idiomas que você quer oferecer suporte e criar o seu próprio hook de tradução, ao invés de usar uma biblioteca para esses fins. Isso para não acrescentar tanto peso de bundle ao seu projeto.</p><h4>Instalando as dependências</h4><p>Primeiro, precisamos instalar as bibliotecas necessárias:</p><pre>npm install react-i18next i18next</pre><p>*Embora o nome, essas dependências não tem relação com o framework “Next.js” do React.</p><h4>Configurando os arquivos de tradução</h4><p>Crie uma pasta locales na raiz do seu projeto e adicione arquivos JSON para cada idioma que deseja suportar.</p><p>Por exemplo, locales/en.json, locales/es.json<strong> </strong>e locales/pt.json, pois aqui queremos oferecer suporte ao inglês, espanhol e português, respectivamente.</p><p>🇺🇸 <strong>locales/en.json</strong></p><pre>{<br>  &quot;welcome&quot;: &quot;Welcome&quot;,<br>  &quot;description&quot;: &quot;This is a simple internationalization example.&quot;<br>}</pre><p>🇪🇸 <strong>locales/es.json</strong></p><pre>{<br>  &quot;welcome&quot;: &quot;Bienvenido&quot;,<br>  &quot;description&quot;: &quot;Este es un ejemplo sencillo de internacionalización.&quot;<br>}</pre><p>🇧🇷 <strong>locales/pt.json</strong></p><pre>{<br>  &quot;welcome&quot;: &quot;Bem-vindo&quot;,<br>  &quot;description&quot;: &quot;Este é um exemplo simples de internacionalização.&quot;<br>}</pre><h4>Configuração do i18next</h4><p>Crie um arquivo i18n.js na raiz do seu projeto para configurar a lib:</p><pre>import i18n from &#39;i18next&#39;;<br>import { initReactI18next } from &#39;react-i18next&#39;;<br>import enTranslation from &#39;./locales/en.json&#39;;<br>import esTranslation from &#39;./locales/es.json&#39;;<br>import ptTranslation from &#39;./locales/pt.json&#39;;<br><br>const resources = {<br>    en: {<br>        translation: enTranslation<br>    },<br>    es: {<br>        translation: esTranslation<br>    },<br>    pt: {<br>        translation: ptTranslation<br>    }<br>};<br><br>const language = localStorage.getItem(&#39;locale&#39;) || navigator.language;<br><br>i18n<br>    .use(initReactI18next)<br>    .init({<br>        resources,<br>        lng: language,<br>        fallbackLng: &#39;pt&#39;,<br>    });<br><br>export default i18n;</pre><p>O que tá acontecendo aqui tá? É intuitivo:</p><ul><li>Carregadas as dependências e os JSONs com os conteúdos internacionalizados, definimos o resources, onde:<br>- Na chave do objeto, temos a linguagem<br>- E, no valor, um objeto com a propriedade translation. Essa propriedade armazena o objeto com o conteúdo da nossa aplicação, já traduzido para aquele idioma. Será um, entre aqueles que definimos no <a href="#b020"><strong>passo anterior</strong></a>, lembra?</li><li>Em seguida, recuperamos a linguagem de preferência do usuário do <a href="https://developer.mozilla.org/pt-BR/docs/Web/API/Window/localStorage"><strong>localStorage</strong></a>, procurando pelo item locale, que setaremos no momento da troca de linguagem. <br>Calma, isso vai fazer mais sentido já já!<br><br>Caso não haja nada nesse item do localStorage, a gente recupera o idioma das configurações do browser do usuário, com navigator.language.</li><li>Chamamos o método init() para que possamos carregar o plugin react-i18next no i18next. Será em cima dele que trabalharemos a configuração de internacionalização.</li><li>E, logo em seguida, chamamos o método init(), passando um objeto de configuração, com:<br>- O objeto resources que acabamos de falar<br>- A linguagem em uso no momento, passada para a propriedade lng <br>- Em fallbackLng configuramos o nosso idioma default, isto é, a língua em que a nossa aplicação será carregada caso: o usuário ainda não tenha selecionado um idioma ou a tradução para a linguagem de preferência do usuário não esteja disponível.</li></ul><h4>Integração com o React</h4><p>No arquivo principal da sua aplicação (geralmente o main.jsx para aplicações React), importe o i18n que exportamos no arquivo que criamos:</p><pre>import React from &#39;react&#39;<br>import ReactDOM from &#39;react-dom/client&#39;<br>import { App } from &#39;./App.jsx&#39;<br>import &#39;../i18n&#39;;<br><br>ReactDOM.createRoot(document.getElementById(&#39;root&#39;)).render(<br>  &lt;React.StrictMode&gt;<br>    &lt;App /&gt;<br>  &lt;/React.StrictMode&gt;,<br>)</pre><h4>Traduzindo…</h4><p>Agora, podemos usar as traduções em nossos componentes. Pra isso, utilizaremos o hook useTranslation para acesso às strings traduzidas:</p><pre>import { useTranslation } from &#39;react-i18next&#39;;<br><br>export function App() {<br>  const { t, i18n } = useTranslation();<br><br>  const changeLanguage = (lng) =&gt; {<br>    i18n.changeLanguage(lng);<br>    localStorage.setItem(&#39;locale&#39;, lng);<br>  };<br><br>  return (<br>    &lt;div&gt;<br>      &lt;h1&gt;{t(&#39;welcome&#39;)}&lt;/h1&gt;<br>      &lt;p&gt;{t(&#39;description&#39;)}&lt;/p&gt;<br>      <br>      &lt;button onClick={() =&gt; changeLanguage(&#39;en&#39;)}&gt;English&lt;/button&gt;<br>      &lt;button onClick={() =&gt; changeLanguage(&#39;es&#39;)}&gt;Espanhol&lt;/button&gt;<br>      &lt;button onClick={() =&gt; changeLanguage(&#39;pt&#39;)}&gt;Português&lt;/button&gt;<br>    &lt;/div&gt;<br>  );<br>}</pre><ul><li>Definimos uma função para lidar com a mudança de linguagem<br>- Essa, chama outra função, a i18n.changeLanguage(), passando a linguagem para qual a aplicação deve passar a ser exibida.<br>- Além de setar a linguagem de preferência do usuário no <a href="https://developer.mozilla.org/pt-BR/docs/Web/API/Window/localStorage"><strong>localStorage</strong></a>, para que a aplicação continue a ser exibida na linguagem que ele quer ao longo dos refreshes de página e tudo mais.<br>*É uma solução extremamente comum que a linguagem escolhida pelo usuário seja guardada em localStorage</li><li>Em seguida, chamamos a função t() recuperada do nosso hook para a tradução das informações “welcome” e “description”, exibindo-as em tela.</li><li>E, por último, temos os nossos botões para a mudança de linguagem, que basicamente chamam a função changeLanguage() que definimos antes para a alteração do idioma de fato. Nisso, é passada a linguagem que a nossa aplicação deverá passar a ser exibida, en, es e pt no nosso exemplo, respectivamente.</li><li>E observe: aqui a abordagem é fazer a mudança de linguagem durante o runtime, com Javascript. Diferente de outras alternativas, como por exemplo a que o Next.js apresenta, em tempo de build.</li></ul><h3>Outras abordagens e ferramentas…</h3><p>Existem outras abordagens e ferramentas para se internacionalizar uma aplicação, dependendo do framework ou biblioteca que você está usando. Por exemplo, o Next.js resolve a i18n com <a href="https://nextjs.org/docs/pages/building-your-application/routing/internationalization"><strong>roteamento</strong></a>, o que significa que podemos ter a aplicação intercionalizada em <strong>tempo de build</strong>, com rotas ou subdomínios determinando o idioma da aplicação, não é um máximo?</p><p>Ao passo que, caso você esteja utilizando um framework como o Docusaurus, para construção de um portal de documentações por exemplo, será necessário verificar <a href="https://www.google.com/search?q=docusaurus+i18n&amp;client=ubuntu-sn&amp;hs=O52&amp;sca_esv=1ea8dac205df0227&amp;channel=fs&amp;sxsrf=ADLYWILNc89Fz2ClRg2PIEYiTC-AT85Umw%3A1721517041109&amp;ei=8UOcZtiwBoOo5OUPmbiWoAQ&amp;ved=0ahUKEwiY7dbd3raHAxUDFLkGHRmcBUQQ4dUDCA8&amp;uact=5&amp;oq=docusaurus+i18n&amp;gs_lp=Egxnd3Mtd2l6LXNlcnAiD2RvY3VzYXVydXMgaTE4bjIFEAAYgAQyCBAAGIAEGMsBMggQABiABBjLATIGEAAYFhgeMggQABiABBiiBEjbHFAAWN0acAF4AZABAJgBfqABmgeqAQMwLji4AQPIAQD4AQL4AQGYAgmgAtgHwgIKECMYgAQYJxiKBcICBxAjGLACGCfCAgcQABiABBgNwgIKEAAYsAMY1gQYR8ICDRAAGIAEGLADGEMYigWYAwCIBgGQBgqSBwMxLjigB-Mo&amp;sclient=gws-wiz-serp"><strong>como o framework lida</strong></a> com o problema de internacionalização e seguir as suas diretrizes para implementar a solução.</p><h3>Conclusão</h3><p>Internacionalizar uma aplicação é um passo importante para torná-la globalmente acessível🌎 Neste artigo, vimos como implementar a internacionalização em uma aplicação React com tradução manual, usando a biblioteca react-i18next. Exploramos também as vantagens e desvantagens das abordagens de tradução manual e automática. <br>Lembre-se de considerar a solução mais adequada para o seu projeto, levando em conta escala e os seus requisitos específicos.</p><p>Ah! Todo o código que passamos juntos durante o artigo está nesse repositório no Github:</p><p><a href="https://github.com/pedrohlucena/blog/tree/master/internacionalizacao_aplicacoes_i18n_traducao_manual">blog/internacionalizacao_aplicacoes_i18n_traducao_manual at master · pedrohlucena/blog</a></p><h3>Bom, é isso, espero que tenha gostado! E se tiver alguma sugestão deixe aí nos comentários 💬</h3><p>Se gostou, dê 1 ou 50 claps (Só clicar 50x na 👏), ou é 1, ou é 50, não tem meio termo.</p><p><strong>Obrigado pela leitura!</strong></p><p><em>Me acompanhe por aí!</em> 😜</p><ul><li>Portfólio: <a href="https://pedrohlucena.vercel.app/">pedrohlucena.vercel.app</a></li><li>GitHub: <a href="https://github.com/pedrohlucena">@pedrohlucena</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/pedrohlucena1">@pedrohlucena1</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d9272bf16c2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploy de SPAs em Cloud AWS com CloudFront e S3]]></title>
            <link>https://medium.com/@pedrohlucena/deploy-de-spas-em-cloud-aws-com-cloudfront-e-s3-2b63ef61618f?source=rss-feb3e5f03bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/2b63ef61618f</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Pedro Lucena]]></dc:creator>
            <pubDate>Fri, 12 Jul 2024 23:40:03 GMT</pubDate>
            <atom:updated>2024-07-20T18:45:00.361Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nOcUCwGVDrYc2iJd.png" /><figcaption>Imagem retirada desse artigo <a href="https://aws.amazon.com/blogs/networking-and-content-delivery/amazon-s3-amazon-cloudfront-a-match-made-in-the-cloud/">https://aws.amazon.com/blogs/networking-and-content-delivery/amazon-s3-amazon-cloudfront-a-match-made-in-the-cloud/</a></figcaption></figure><p>Implantar Single Page Applications (SPAs) na AWS é uma maneira poderosa e eficiente de hospedar suas aplicações web, garantindo alta disponibilidade e performance. Neste artigo, vou guiá-lo passo a passo através do processo de deploy desse tipo de aplicação utilizando recursos AWS como o S3 e o CloudFront, explicando cada um deles e suas devidas configurações. Farei o deploy de uma aplicação React ao longo do artigo, mas o processo é aplicável a qualquer biblioteca ou framework para SPAs, como o Angular ou o Vue.</p><h3>Pré-requisitos 📋</h3><ul><li>Ter uma conta na AWS<br>*Caso você ainda não tenha uma, você pode <a href="https://aws.amazon.com/resources/create-account"><strong>cria-la aqui</strong></a>.</li><li>Aplicação SPA pronta para deploy<br>*Como dito, eu usarei o React.</li></ul><h3>1. Configuração do S3</h3><p>O <a href="https://aws.amazon.com/pt/s3/"><strong>Amazon Simple Storage Service</strong></a> — conhecido popularmente como S3 — é um serviço da AWS que serve para armazenamento de arquivos, os chamados “objetos”. Quando buildamos uma aplicação SPA, são gerados diversos arquivos estáticos, HTML, CSS, Javascript e arquivos de imagem. Construindo esse tipo de aplicação, provavelmente você já viu isso em algum momento da sua vida, rodando um npm run build e.g:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/351/1*u4aasPXf1rUPu8xUaxg2KA.png" /></figure><p>O barato é que a gente vai colocar esses arquivos em uma bucket S3 <br>— que vai lidar com o armazenamento deles para nós — e usar o CloudFront pra fazer a entrega desse conteúdo, através da sua rede global de pontos de presença✨</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*LwtgwPhDjNB5LtsR.gif" /></figure><p><strong>Mas antes de começarmos… Um alerta</strong>🚨</p><p>A UI da AWS muda constantemente… Então, os prints que você ver aqui podem estar diferentes do que você ver na tela da sua máquina, quando você tiver seguindo o passo a passo comigo. Embora isso possa acontecer, não significa que o conteúdo está desatualizado, a AWS é assim mesmo. Ajustes pequenos de UI, coisas mudarem de lugar é extremamente comum quando você tiver usando a interface deles, se tornando muito difícil pra mim deixar o artigo sempre atualizado com a última versão da UI que eles estiverem utilizando. Portanto, se for esse o seu caso, relax… <br>O que eu escrevi aqui muito provavelmente não está desatualizado, beleza? Acredito fortemente que esse processo que passaremos não vai mudar tão cedo. Dito isso, bora🔥</p><p><strong>Vamos a criação!</strong></p><p>1. Acesse o Console da AWS e navegue até o serviço S3.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4iYxSJeF40ckdzuAHS556A.png" /></figure><p>2. Clique em “Create bucket”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z1s4wrk5jlWfrQP-QKlyoQ.png" /></figure><p>3. E nomeie o seu bucket e escolha a região desejada. No meu caso, criarei o bucket “spa-deploy-static-files”, na região de US East (Ohio) us-east-2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x_Espu7gBZuczpxdvVLlsA.png" /></figure><p>Caso você queira mudar a região onde será criada o seu bucket, você faz isso aqui em cima:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*28fLXoRdrHX1-25jyMewHA.png" /></figure><p>*Nomes de buckets devem ser únicos globalmente. Se você escolher um nome que é muito comum, como “myawsbucket” por exemplo, você tomará um erro:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/608/1*XHbjnE_TGVZpsOpi2tFt1A.png" /></figure><p>5. Desmarque a opção “Block all public access”. Isso implicará que todos os arquivos presentes no bucket possam ser acessados de forma pública. Caso você não queira isso, você pode falar pra AWS que <a href="https://repost.aws/questions/QUyDcwT1IrQZOniiEB2x0q6A/correct-process-for-configuring-s3-bucket-so-only-cloudfront-can-access"><strong>o seu bucket só pode ser acessado de uma distribuição CloudFront</strong></a> (recurso que veremos mais adiante), isso se dá através do AWS origin access identity (OAI). <br>Dessa forma:</p><ul><li>Caso alguém tente acessar o bucket de forma direta, ela tomará um <br>NOT ALLOWED.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/270/0*5ROS5skFgUhTNwWv.gif" /></figure><ul><li>Só que, quando o CloudFront tentar acessar esses mesmos arquivos, pra fazer as suas distribuições, ele poderá fazer o acesso normalmente.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*8ky5FTX0L4q-fFZT" /></figure><p>No nosso caso, seguiremos com um exemplo mais básico, liberando geral mesmo.</p><p>Confirme que você entende as implicações de tornar os objetos públicos e vamos nessa!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*m75Gle2dq_Nywqloh8JbvQ.png" /></figure><p><strong>Mas antes da criação…</strong></p><p><strong>⚠️ Certifique-se de que a criação do bucket está dentro do </strong><a href="https://aws.amazon.com/free"><strong>Free Tier</strong></a><strong> ⚠️<br></strong>*Desde quando eu comecei a estudar Cloud, em 2022, buckets S3 estão inclusas no Free Tier. Então muito provavelmente elas ainda estão, tá?</p><p>Ao lidar com computação em nuvem a gente sempre tem que estar muito veiaco com o billing dos recursos que estamos utilizando, logo, pensar: <br>“Será que eu serei cobrado por esse recurso que eu estou criando aqui no console? Isso tá incluso no Free Tier?”. <br>Isso é algo que você <strong>SEMPRE</strong> tem que ter em mente ao lidar com qualquer provedor de ☁️, como GCP, Azure, etc...</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/753/1*j2ST661RqLZ9wcyimpHOKA.png" /><figcaption>Imagem retirada do site: <a href="https://www.dicionarioinformal.com.br/veiaco/">https://www.dicionarioinformal.com.br/veiaco</a></figcaption></figure><p>*Isso evita de você ter que ligar desesperado pro teu amigo que manja de Cloud em uma tarde de domingo não entendendo algumas cobranças indesejadas no seu cartão. Eu mesmo nunca fiz isso… Né <a href="https://medium.com/u/51a47a260960">Arthur Machado</a> ?</p><p>5. Por fim, vamos sentar o dedo no “Create bucket” pra criarmos o <br>nosso balde.</p><h4>Configurando o Bucket S3</h4><p>1. Selecione o bucket recém-criado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h1jB9pJxUGpMfUDjJtAesA.png" /></figure><p>2. Vá até a aba “Permissions”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QYtmoIV_N3w-W7F1lmFt1A.png" /></figure><p>E clique em “Edit” em “Bucket policy”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zcQsrnyJkQBA2Ak5b_lfFQ.png" /></figure><p>Feito isso, cole esse código lá — substituindo o “nome-seu-bucket” <br>pelo nome do seu bucket — e clique em salvar✅</p><pre>{<br>    &quot;Version&quot;: &quot;2012-10-17&quot;,<br>    &quot;Statement&quot;: [<br>        {<br>            &quot;Effect&quot;: &quot;Allow&quot;,<br>            &quot;Principal&quot;: &quot;*&quot;,<br>            &quot;Action&quot;: &quot;s3:GetObject&quot;,<br>            &quot;Resource&quot;: &quot;arn:aws:s3:::nome-seu-bucket/*&quot;<br>        }<br>    ]<br>}</pre><p>Aqui, estamos <strong>PERMITINDO</strong> que <strong>QUALQUER PRINCIPAL</strong> possa <strong>RECUPERAR OBJETOS</strong> do <strong>NOSSO BUCKET</strong>. Esse código, em suma, diz isso.</p><ul><li>arn:aws:s3:::nome-seu-bucket/* é o <strong>Amazon Resource Name (ARN)</strong>, como se fosse o “nome completo” do nosso bucket.</li><li>Um principal, de forma simples, é qualquer entidade que possa fazer solicitações para os serviços da AWS.</li></ul><p>3. Agora, vá até a aba “Properties”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ez_92w01JqEvEmJy6BMIqA.png" /></figure><p>E clique em “Edit” na parte de “Static website hosting”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A86_WTpHa7etnq9UHmXQ6Q.png" /></figure><p>Essa configuração transforma seu bucket S3 em um servidor web estático, permitindo que os arquivos da sua aplicação sejam servidos como um site.</p><p>4. Marque “Enable” para o “Static website hosting”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W3zPo6h36JKlAmzD-VCGXA.png" /></figure><p>E configure os seguintes campos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3QPX8WK3oEztZmizqSpEVg.png" /></figure><p>— Index document: index.html <br> — Error document: index.html</p><p>Aqui estamos aptos a selecionar o arquivo principal que deverá ser carregado e o arquivo exibido em caso de erro, respectivamente. <br>No nosso caso, não faremos essa diferenciação, para ambos os casos, o arquivo “index.html” será mostrado em tela.</p><p>5. Salve as mudanças e tá pronto! Temos um servidor configurado, <br>facinho facinho😎</p><h4>Upload dos arquivos</h4><p>1. Lembra que eu falei que o bucket S3 serve para armazenamento de arquivos? O nosso bucket tá configurado! Mas ainda sem arquivos dentro…O que faremos agora é inserir os objetos dentro dele.</p><p>Pra isso, navegue até a aba “Objects”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rsEodFdRwEVZAgjolkyWSQ.png" /></figure><p>2. Clique em “Upload” e suba os arquivos do build da sua SPA.<br>*Esses arquivos podem ser facilmente obtidos — muito provavelmente — pelo comando npm run build. A maioria das ferramentas de CLI para criação de projetos, como <strong>create vite</strong>, <strong>create-react-app</strong>, ou <strong>ng new </strong>incluem esse comando npm nos projetos criados a partir delas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5xPrONtaCK_P-IWoo7O3yg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FaAxm0Xch5Sga3CRTsRI4w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c3sjI_E4H1CFvj_ZpdT3vw.png" /></figure><p>O que tá acontecendo aqui é, literalmente, aquele upload de arquivos que você faz no Google Drive. A ideia é exatamente a mesma…</p><p>Para automação de um processo de deploy por exemplo, você poderia colocar um Jenkins da vida olhando pra uma determinada branch do Git e, assim que houver uma mudança nessa branch, uma pipeline é acionada, o build acontece e os arquivos desse build sobem pra bucket via <a href="https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/index.html"><strong>AWS CLI</strong></a>, por exemplo. Se vocês tem interesse em ler sobre isso, posso trazer um artigo só falando como fazer o setup de uma pipeline de CI &amp; CD para automação do processo de implantação de front-ends, só você deixar um comentário aí💬</p><p>Os arquivos que eu subi pro meu bucket são esses:</p><p><a href="https://github.com/pedrohlucena/blog/tree/master/deploy-spas-cloud-aws-cloudfront-s3/react-spa/dist">blog/deploy-spas-cloud-aws-cloudfront-s3/react-spa/dist at master · pedrohlucena/blog</a></p><h4><strong>Billing</strong></h4><p>O S3 cobra, basicamente, por <strong>armazenamento</strong> e <strong>requisições</strong>. No <a href="https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&amp;all-free-tier.sort-order=asc&amp;awsf.Free%20Tier%20Types=*all&amp;awsf.Free%20Tier%20Categories=*all&amp;all-free-tier.q=Amazon%2BS3&amp;all-free-tier.q_operator=AND"><strong>Free Tier</strong></a>, você tem <strong>5GB de armazenamento gratuito por 12 meses</strong>. <br>Consulte a <a href="https://aws.amazon.com/s3/pricing"><strong>página de preços do S3</strong></a> para mais detalhes.</p><h3>2 - Configuração do CloudFront</h3><p>Não dá pra falar do <a href="https://aws.amazon.com/pt/cloudfront/"><strong>Amazon CloudFront</strong></a>, sem falar de CDN. <br>CDN é um <a href="https://pt.wikipedia.org/wiki/Acr%C3%B3nimo"><strong>acrônimo</strong></a> para <strong>C</strong>ontent <strong>D</strong>elivery <strong>N</strong>etwork, que através da sua <strong>rede de entrega de conteúdo</strong> — tradução literal do termo — distribui algum tipo de conteúdo globalmente🌎, de forma a:</p><ul><li>Reduzir a latência para o usuário final ⬇️</li><li>E aumentar a disponibilidade do conteúdo a ser entregue ⬆️</li></ul><h4>Vamos detalhar isso… 🤓</h4><p>Uma CDN (Content Delivery Network) é uma rede de servidores distribuídos geograficamente ao redor do mundo. Esses servidores cacheiam os conteúdos estáticos do seu site, HTML, CSS, JavaScript e imagens. Dessa forma, quando um usuário acessa o seu site, a rede de entrega retorna o conteúdo a partir do servidor mais próximo geograficamente da localização do usuário que fez a requisição, reduzindo a latência e melhorando a velocidade de carregamento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Fo_Su26MiqEG5a1q.png" /><figcaption>Imagem retirada do artigo <a href="https://www.cloudflare.com/pt-br/learning/cdn/what-is-a-cdn/">https://www.cloudflare.com/pt-br/learning/cdn/what-is-a-cdn</a></figcaption></figure><p>Os servidores CDN comunicam-se com um servidor de origem (o Origin Server) para obter os conteúdos mais recentes sempre que necessário. Quando o conteúdo solicitado pelo usuário não está em cache — por esse cache ter sido invalidado por exemplo — o servidor CDN solicita esse conteúdo ao servidor de origem, armazena-o em cache e o entrega ao usuário. Dessa forma, da próxima vez que um usuário solicitar o conteúdo do nosso site próximo a esse servidor que acabou de instaurar um cache, o que está em cache é retornado, não sendo necessário fazer a busca no servidor de origem novamente, é um fluxo...</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*e6Pq9sS3jaXmrsev.png" /><figcaption>Imagem retirada do artigo <a href="https://javaadpatel.com/why-cdn-improve-performance/">https://javaadpatel.com/why-cdn-improve-performance</a></figcaption></figure><p>Isso resulta em uma experiência de navegação mais rápida e eficiente para os usuários, independentemente de onde eles estejam no globo🌍 <br>(ou no plano📄, dependendo do que você acredita).</p><p>É importante falar que a Content Delivery Network é um <strong>CONCEITO</strong>, CDN não é algo que é exclusivo da Amazon, por exemplo. Em cima desse conceito, provedores de Cloud oferecem serviços que implementa-o. <br>A <strong>Amazon</strong> oferece isso através do <strong>CloudFront</strong>, mas a <strong>Google</strong> oferece através do <a href="https://cloud.google.com/cdn?hl=pt-BR"><strong>Cloud CDN</strong></a>, enquanto a <strong>Azure</strong> oferece através da <a href="https://azure.microsoft.com/pt-br/products/cdn"><strong>Azure CDN</strong></a>. <br>Em cima de <strong>UM CONCEITO</strong> temos <strong>diversas implementações</strong>, percebem?</p><h4>Criando uma Distribuição CloudFront</h4><p>1. No Console da AWS, navegue até o serviço CloudFront.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q60x5z3r1fBfbnf1q5eNyQ.png" /></figure><p>2. Clique em “Create Distribution”. Essa ação inicia o processo de criação de uma distribuição CloudFront.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hdI41o2LqqsW4WEJjBAkyQ.png" /></figure><p>Uma <strong>distribuição CloudFront</strong> é um conjunto de configurações que define como o conteúdo será entregue aos usuários finais, na ideia de CDN que conversamos agorinha. Aqui podemos escolher a origem do conteúdo (além da bucket S3, um servidor EC2 também é possível), definir políticas de cache, configurar SSL/TLS, definir comportamentos de cache baseados em paths específicos, configuração de logging para monitoramento detalhado, entre outras especificações.</p><p>3. Em “Origin Domain”, iremos selecionar o domínio para o bucket S3 que criamos juntos anteriormente. Esse domínio é criado automaticamente pela AWS, na criação de um bucket.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i1VRymB2-J4EMItTLTwVvw.png" /></figure><p>4. Uma vez que fizermos isso, a AWS nos apresentará esse warning:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/616/1*mKWHfYncc1eTsdlv574XoA.png" /></figure><p>Com isso, é só clicarmos em “Use website endpoint” que tá susa🤙</p><p>Antes, você tinha selecionado o endpoint da bucket para esse campo. <br>Ao clicar nesse botão, o nosso Origin Domain será substituído pelo endpoint do S3 website, que criamos quando configuramos o Static website hosting do nosso bucket. Usar esse domínio é recomendado, caso a gente planeje usar a distribuição como um site.</p><p>5. Em “Web Application Firewall (WAF)” iremos selecionar “Do not enable security protections”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MocLqn06gpb4Z8qavkvpXQ.png" /></figure><p>Essa configuração diz respeito ao <a href="https://aws.amazon.com/pt/waf/"><strong>AWS Web Application Firewall (WAF)</strong></a>. <br>O WAF é uma camada de segurança a mais que podemos colocar, que permite que configuremos regras para filtragem e monitoramento do tráfego HTTP/HTTPS que chega ao CloudFront. Isso ajuda a protegermos nossas aplicação web contra ataques comuns, como SQL injection e cross-site scripting (XSS), além de permitir bloquear ou permitir requisições baseadas em critérios específicos, como IP de origem ou cabeçalhos HTTP.<br>Em resumo, o WAF abstrai parte da segurança de nossas aplicações web, para que não nos preocupemos com isso e possamos dormir melhor a noite😴<br>*Esse é um serviço AWS a parte que pode também ser utilizado em outras aplicações web, não apenas sites, em específico.</p><p>Como o nosso caso é mais simples e esse serviço não está incluso no <br>Free Tier, vamos sem ele mesmo…</p><p>5. Vamos deixar as demais configurações como padrão. Agora é só clicarmos em “Create Distribution” para que a criação seja iniciada. <br>Quanto a cobranças 💲, pode ficar tranquilo! A criação da distribuição, por si só, não vai te gerar cobranças, você estando dentro do Free Tier ou não.</p><p>6. Depois de um tempinho esperando… ⌚ A nossa distribuição será criada!<br>*Distribuições CloudFront demoram um pouquinho para serem criadas mesmo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7D9-AssUniuk-0cyYzMxvA.png" /></figure><p>Você consegue saber quando o deploy da sua distribuição foi concluído quando o campo “Last Modified” sair de:<br>“Deploying” =&gt; “Month DD, YYYY at H:MM:SS AM/PM UTC”<br>Como a imagem apresenta.</p><p>Com isso, o CloudFront vai fornecer um domínio para que acessemos a nossa publicação:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D4CzUWD-KFrn6ITDPILHKg.png" /></figure><p>E clicando nesse link:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3SWtq2PBe-O-NvBT3wHsSw.png" /></figure><p>Voilá, nós conseguimos🎉</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*M6fRF5eMHEy7cHpC.gif" /></figure><h4><strong>Billing</strong></h4><p>A Amazon te cobrará pelo uso do CloudFront com base na quantidade de dados transferidos e requisições. No <a href="https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&amp;all-free-tier.sort-order=asc&amp;awsf.Free%20Tier%20Types=*all&amp;awsf.Free%20Tier%20Categories=*all&amp;all-free-tier.q=CloudFront&amp;all-free-tier.q_operator=AND"><strong>Free Tier</strong></a>, você tem 50GB de transferência de dados gratuita por 12 meses. <br>Consulte a <a href="https://aws.amazon.com/cloudfront/pricing/"><strong>página de preços do CloudFront</strong></a> para mais detalhes.</p><h3>3 - Configuração do DNS (Opcional)</h3><p>Se você já possui um domínio próprio, é possível configurar o Route 53 <br>— outro serviço do Jeff Bezos — para gerenciar o DNS e apontar seu domínio para a distribuição CloudFront.</p><p>1. No Console da AWS, navegue até o serviço Route 53.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ku8tY2aziV8whf07kAJo2A.png" /></figure><p>2. Nele, navegue até Hosted Zones.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u-7HDc7uJgdKtkYBeTi0jg.png" /></figure><p>3. Crie uma zona hospedada, clicando nesse botão:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yS3oobuW4-N-WOqXo-DrQg.png" /></figure><p>E siga o fluxo de criação, configurando a zona conforme a sua necessidade.</p><p>Ou então, selecione uma previamente criada:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/913/0*0ycGpHhTRhRGBQxV.jpeg" /><figcaption>Imagem retirada do artigo <a href="https://medium.com/@rogernem/hosting-my-static-website-in-an-aws-s3-bucket-cloudfront-route-53-3ad8d26b22f1">https://medium.com/@rogernem/hosting-my-static-website-in-an-aws-s3-bucket-cloudfront-route-53-3ad8d26b22f1</a></figcaption></figure><p>4. E, por fim, clique no botão “Create record”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/913/0*8thPRWtEYPZS3DyS.jpeg" /><figcaption>Imagem retirada do artigo: <a href="https://medium.com/@rogernem/hosting-my-static-website-in-an-aws-s3-bucket-cloudfront-route-53-3ad8d26b22f1">https://medium.com/@rogernem/hosting-my-static-website-in-an-aws-s3-bucket-cloudfront-route-53-3ad8d26b22f1</a></figcaption></figure><p>E siga o fluxo de criação para a adição de um registro A (ou CNAME) apontando para o domínio da sua distribuição CloudFront:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/913/0*IqeAhyG-z9x1U9q0.jpeg" /><figcaption>Imagem retirada do artigo: <a href="https://medium.com/@rogernem/hosting-my-static-website-in-an-aws-s3-bucket-cloudfront-route-53-3ad8d26b22f1">https://medium.com/@rogernem/hosting-my-static-website-in-an-aws-s3-bucket-cloudfront-route-53-3ad8d26b22f1</a></figcaption></figure><p>*Nós não nos aprofundaremos tanto nessa parte de configuração de DNS no geral. Caso vocês queiram um artigo só pra isso, <strong>let me know</strong>! <br>Deixa um comentário aí que eu providencio😉</p><h3>Template CloudFormation</h3><p>Boa! Chegamos ao fim.</p><p>Agora. Agora imagina que a empresa que você trabalha tenha dezenas e dezenas de clientes e você precisa criar uma instância da sua aplicação, para cada um deles…<br><strong>OU ATÉ PIOR! 😈</strong> Você pode precisar criar, para cada cliente, um ambiente de:</p><ul><li>Desenvolvimento</li><li>Testes</li><li>Homologação</li><li>E produção</li></ul><p>Caso a companhia tenha apenas 3 clientes, você precisa fazer todo esse processo mais de 10x (3 clientes x 4 ambientes para cada um = 12). <br>Inviável né amigo? Haja mouse pra tanto click🖱️</p><p>É aí que o conceito de <a href="https://pt.wikipedia.org/wiki/Infraestrutura_como_C%C3%B3digo"><strong>Infrastructure as Code (IaC)</strong></a><strong> </strong>consegue ajudar a gente!</p><p>O negócio é que tudo o que fizemos até agora, via console da AWS, pode também ser feito via código. A gente define a nossa infraestrutura — no nosso caso, principalmente o bucket e a distribuição — através de um <a href="https://aws.amazon.com/cloudformation/resources/templates/"><strong>CloudFormation template</strong></a> e podemos replicar essa infra quantas vezes quisermos, para quantos clientes ou ambientes forem necessários! <br>E, ainda, caso você precise deletar todos esses recursos, você consegue fazer isso muito mais fácil! Porque é só deletar a chamada “stack” — a responsável pela criação de todos esses recursos — que todos eles serão deletados de maneira automática… DevOps é 10 né? Eu acho um máximo🤩</p><p>Então, aqui está o template para automatizar tudoooo o que a gente fez manualmente até então:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d990c542d80411035c4307d516a65ccc/href">https://medium.com/media/d990c542d80411035c4307d516a65ccc/href</a></iframe><p>1. Com esse template em mãos, vamos criar a nossa stack!</p><p>Uma stack do CloudFormation é um conjunto de recursos da AWS que são geridos como uma única unidade. Esses recursos são definidos em um template escrito em JSON ou YAML, que especifica os serviços e configurações necessários para a aplicação. Com o CloudFormation, você pode provisionar, atualizar ou deletar todos os recursos de uma aplicação de maneira coordenada e repetível, garantindo a consistência da infraestrutura ao longo do ciclo de vida do projeto.</p><p>Pra criação dessa stack, vamos até o serviço “CloudFormation”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GmoLSWhlLoxGbNhwexQ9TQ.png" /></figure><p>2. Lá, clicaremos em “Create stack” e depois em “With new resources (standard)”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0MSCvPFqUFsETehqmOKI6w.png" /></figure><p>3. Aqui, vão ter várias opções para a gente “passar” o nosso template pro CloudFormation entendê-lo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U3ZehLpAIjQpaSt7yR-o5g.png" /></figure><p>Você pode:</p><ul><li>Passar uma URL do Amazon S3, com o caminho para o nosso template.<br>Sim, você pode usar o S3, que falamos agora a pouco, para armazenamento de templates CloudFormation…</li><li>Fazer upload de um arquivo .yaml contendo o nosso template nele</li><li>Passar esse template pro CloudFormation através de um repositório Git</li><li>Escolher sample templates</li><li>Etc…</li></ul><p>Aqui, iremos de uma forma mais simples, fazendo o upload do arquivo do nosso template presente nossa máquina, para o CloudFormation.</p><p>Pra isso, vamos precisar criar o arquivo no nosso local! Portanto, copie o código do template logo ali em cima e crie um arquivo na sua máquina com a extensão “.yaml”, contendo o conteúdo que você copiou.</p><p>4. Agora é subir esse arquivo que acabamos de criar para o serviço. <br>Iremos em:</p><p>“Choose an existing template”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*flgaNoOu4XOGvy9ac_uOXA.png" /></figure><p>“Upload a template file”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VJLzyy2QVwIKggwyOhv6Hg.png" /></figure><p>E clicamos em “Choose file”, em “Upload a template file”. Depois, você irá selecionar o arquivo .yaml com o template que você criou em passos anteriores</p><p>Feito isso, é só clicar em “Next”!</p><p>5- Nomearemos a nossa stack:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VnXdvxw-Yb6Zt7foE4SSTQ.png" /></figure><p>6- E preencheremos os parâmetros dela. Mas peraí… Que parâmetros são esses?</p><p>No CloudFormation, é possível definir <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html"><strong>Parameters</strong></a>, valores de entrada que podemos passar para os nossos templates, que permitem tornarmos-os mais dinâmicos de deploy para deploy.</p><p>No nosso caso, temos um parâmetro BucketName, observem:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/568/1*Q0GpTnSmiLGsR9ZQxCyH5A.png" /></figure><p>Esse, como o próprio nome já diz de forma intuitiva, define o nome que a nossa bucket terá.</p><p>Então, nessa parte do nosso form, preencheremos o parâmetro BucketName, que, por sua vez, definirá o nome que a nossa bucket terá…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QsxE8JM-qDhp4Sdp8scggw.png" /></figure><p>Preencheremos-o com “spa-deploy-static-files”, o mesmo nome que tínhamos definido para o nosso bucket pelo Console.</p><p>Feito isso, “Next”.</p><p>7. Agora — a melhor moda Windows — next, next, next neles!<br>*Siga dando “Next”, para manutenção das configurações default, até o último step. Onde clicaremos em “Submit” e começaremos a criação da nossa stack…</p><p>A stack sendo criada:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nT8-7WP7stfkM9apqtRUaA.png" /></figure><p>Aqui, todos os recursos AWS que definimos que queríamos fazer a criação, começarão a ser criados. Podemos ver os logs da criação aqui:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*frFKpADwFKmReAVbQri1Ew.png" /></figure><p>8. Depois de um tempo, a stack irá para o status de <strong>CREATE_COMPLETE</strong>, consolidando a finalização da criação dos recursos da stack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*P_ozHPYrIPGZW4dNImlR7w.png" /></figure><p>Só não se esqueça que, uma vez que esses recursos estejam criados, você vai precisar subir os arquivos do build do seu SPA pra bucket… Afinal, ela foi criada vazia!</p><h3>Deleção dos recursos</h3><p>Concluiu sua POC? Legal! Agora, eu preciso te lembrar de deletar os recursos que criamos juntos… <br><em>Ah! Como eu gostaria de ter recebido esses avisos na minha carreir</em>a😂 <br>Mesmo que você ainda esteja com seu Free Tier, isso é bem recomendado de fazer (caso você não vá mais utilizar os recursos, é claro). Porque vai que você esquece esses recursos aí, o período de testes acaba, você não lê o <br>e-mail da AWS te avisando e só percebe quando chegou aqueles 10 conto no seu cartão de crédito. Melhor previnir do que remediar… Bora lá! 🗑️</p><p>Essa parte é bem simples, então não trabalharemos com prints, ó:</p><ul><li>Pra bucket, é tranquilo, você só vai selecionar ela e clicar em “Delete”, sem segredo…</li><li>Já as distribuições CloudFront só podem ser deletadas caso estejam desabilitadas. Portanto:<br>- Primeiro, desabilite a sua distribuição, selecionando-a na listagem e clicando em “Disable”. Assim como a maioria das edições em distribuições, vai demorar um pouquinho até a desabilitação acontecer.<br>*Mexer com CloudFront é chatinho por conta disso.<br>- Com ela desabilitada, selecione-a e clique em “Delete”</li></ul><h3>Conclusão</h3><p>E aí, o que você achou? Foi mais fácil… Mais difícil do que você esperava?Deployar uma SPA na AWS utilizando S3 e CloudFront é uma maneira eficiente de garantir que sua aplicação seja rápida, segura e disponível globalmente. Espero que este guia tenha sido útil para você😊</p><h3>Bom, é isso, espero que tenha gostado! E se tiver alguma sugestão deixe aí nos comentários 💬</h3><p>Se gostou, dê 1 ou 50 claps (Só clicar 50x na 👏), ou é 1, ou é 50, não tem meio termo.</p><p><strong>Obrigado pela leitura!</strong></p><p><em>Me acompanhe por aí!</em> 😜</p><ul><li>Portfólio: <a href="https://pedrohlucena.vercel.app/">pedrohlucena.vercel.app</a></li><li>GitHub: <a href="https://github.com/pedrohlucena">@pedrohlucena</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/pedrohlucena1">@pedrohlucena1</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b63ef61618f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GraphQL: Uma alternativa ao REST]]></title>
            <link>https://medium.com/@pedrohlucena/graphql-uma-alternativa-ao-rest-7deb5b2dd64d?source=rss-feb3e5f03bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/7deb5b2dd64d</guid>
            <category><![CDATA[performance-optimization]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[api-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[graphql]]></category>
            <dc:creator><![CDATA[Pedro Lucena]]></dc:creator>
            <pubDate>Sun, 07 Jul 2024 17:41:20 GMT</pubDate>
            <atom:updated>2024-07-07T17:41:20.642Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7alzNTxcpGDQ80PQW_NHRw.jpeg" /><figcaption>Imagem tirada desse artigo: <a href="https://wide.net.br/analise-de-grafos/">https://wide.net.br/analise-de-grafos</a></figcaption></figure><p>As APIs REST dominaram a web por muitos e muitos anos, mas o lançamento do GraphQL pelo Facebook em 2015 trouxe uma nova abordagem para o desenvolvimento de APIs. Na época, diversos foram os rumores sobre a possibilidade do GraphQL substituir o REST, o que claramente não se consolidou. Contudo, o GraphQL oferece vantagens significativas que merecem a sua atenção. Então vem comigo! Vamos explorar os principais conceitos do GraphQL e entender suas diferenças em relação ao REST nesse artigo.</p><h3>O que é GraphQL ? 🤔</h3><p>O GraphQL é uma linguagem de consulta, assim como o SQL, só que ao invés de termos um banco de dados atrás dessa consulta, temos uma API. Desenvolvida pelo Facebook em 2012, a ferramenta oferece uma abordagem mais eficiente e flexível para consumo de APIs, em comparação com o REST. Seu grande diferencial é a sua flexibilidade com consultas, possibilitando clientes a solicitar estritamente os dados de que precisam, nem mais, nem menos, o que ocasiona em uma menor quantidade de dados transferidos pela rede e melhora da performance das aplicações, por consequência. Além disso, sua estrutura tipada permite uma documentação automática e uma validação de consultas mais robusta, facilitando tanto o desenvolvimento quanto a manutenção de APIs mais complexas.</p><h3>Principais conceitos do GraphQL 📖</h3><h4>Schemas</h4><p>No coração do GraphQL está o conceito de <strong>schema</strong>. Aqui a gente tá falando da definição central de uma API GraphQL, onde são definidos:</p><ul><li>A estrutura dos dados que podem ser consultados</li><li>As operações que podem ser realizadas neles</li><li>E a forma com que esses dados se relacionam.</li></ul><pre>schema {<br>  query: Query<br>  mutation: Mutation<br>}</pre><p>Um schema também define tipos, queries e mutations, além das subscriptions, de forma opcional. Trataremos de cada um desses termos mais adiante na nossa jornada no mundo dos grafos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mliPwsG3-QS3Kmf6.jpg" /><figcaption>Imagem retirada desse link: <a href="https://collider.com/the-lord-of-the-rings-sean-bean-climbed-mountain/">https://collider.com/the-lord-of-the-rings-sean-bean-climbed-mountain</a></figcaption></figure><h4>Types</h4><p>Os types (tipos) são as unidades que compõem o schema. Eles definem os formatos dos dados, especificando os campos disponíveis para cada tipo de dado. Ironicamente, temos tipos, de types, sendo os principais:</p><p>1.<strong> Object Types</strong>: Definem um determinado conjunto de campos.</p><pre>type User {<br>  id: ID!<br>  name: String!<br>  email: String!<br>}</pre><p>E o interessante é que types podem sim, referenciar outros types, como segue o exemplo:</p><pre>type Book {<br> id: ID!<br> title: String!<br> author: Author!<br>}<br><br>type Author {<br> id: ID!<br> name: String!<br>}</pre><p>Essa não é uma exclusividade dos Object Types e sim uma característica dos próprios tipos em si.</p><p>2.<strong> Scalar Types</strong>: São os tipos primitivos que já conhecemos, como Int, Float, String, Boolean e ID.</p><p>3.<strong> Enum Types</strong>: São como os enums da programação orientada a objetos: um conjunto fixo de valores possíveis para aquele tipo.</p><pre>enum Role {<br>  ADMIN<br>  USER<br>  GUEST<br>}</pre><p>4.<strong> Input Types</strong>: Tipos que servem o fim de serem usados como argumentos, para mutations e queries.</p><pre>input CreateUserInput {<br>  name: String!<br>  email: String!<br>}</pre><p>5.<strong> Interface Types</strong>: Tipo abstrato que pode ser implementado por outros tipos, a famosa ✨abstração✨ que estamos tão acostumados na engenheria de software.</p><pre>interface Person {<br>  id: ID!<br>  name: String!<br>}</pre><p>6.<strong> Union Types</strong>: Tipo que pode ser um, entre os diversos tipos diferentes especificados.</p><pre>union SearchResult = User | Post</pre><p>Aqui, o SearchResult pode ser OU um User, OU um Post.</p><p>Se você está acostumado com Typescript, um pouco disso deve ter soado familiar pra você…</p><p>Então, conseguimos perceber que o schema vai mais pra uma vibe de ser uma estrutura global, que organiza e relaciona todos os types, definindo a raiz de todas as queries e mutations possíveis no sistema. Ao passo que os types em si, são as peças individuais, os blocos de construção que vão compor o schema, especificando como os dados são estruturados e quais operações são possíveis sobre esses dados.</p><h4>Queries</h4><p>As queries são usadas para a leitura dos dados no GraphQL. E aqui chegamos a grande característica que marca essa tecnologia: clientes diferentes podem solicitar dados de resposta diferentes entre os disponíveis para consulta, de acordo com suas necessidades. Isso resulta em respostas mais precisas e eficientes dos nossos endpoints!</p><p>Para a definição de query a seguir, por exemplo:</p><pre>type Query {<br> book(id: ID!): Book<br> books: [Book]<br>}</pre><p>Definimos que, podemos:</p><ul><li>Tanto buscar um livro pelo seu ID (book(id: ID!): Book)</li><li>Como fazer a busca de todos os livros (books: [Book])</li></ul><p>Logo, um cliente estaria apto a fazer a seguinte consulta:</p><pre>{<br>  book(id: &quot;1&quot;) {<br>    title<br>    author {<br>      name<br>    }<br>  }<br>}</pre><ul><li>Onde queremos recuperar o livro de id=1</li><li>Sendo que, desse livro, queremos recuperar o seu título (title) e o nome do seu autor (author.name)</li></ul><p>E um dado assim, poderia ser retornado:</p><pre>{<br>  &quot;data&quot;: {<br>    &quot;book&quot;: {<br>      &quot;title&quot;: &quot;Introdução ao GraphQL: Busca de Dados com Abordagem Declarativa Para Aplicações web Modernas&quot;,<br>      &quot;author&quot;: {<br>        &quot;name&quot;: &quot;Alex Banks e Eve Porcello&quot;<br>      }<br>    }<br>  }<br>}</pre><p>Para além desse exemplo mais simples, o GraphQL também oferece recursos avançados para otimizar consultas, como a possibilidade de limitar o número de registros retornados através de argumentos como limit e offset, esses que ajudam bastante na implementação de paginação. Além disso, na parte de consultas, é possível aplicar filtros utilizando argumentos específicos para campos, como filter e sort, permitindo queries mais refinadas e personalizadas. A tecnologia também suporta a combinação de múltiplas queries em uma única solicitação, reduzindo a necessidade de múltiplas chamadas à API e melhorando a eficiência da comunicação entre o cliente e o servidor.</p><h4>Mutations</h4><p>As mutations são usadas para modificar dados, em suma, as letras <strong>C</strong>, <strong>U</strong> e <strong>D</strong> do famoso <strong>C</strong>R<strong>UD</strong>. Assim como as queries, elas permitem que os clientes especifiquem exatamente quais dados querem alterar e quais informações precisam na resposta:</p><pre>mutation {<br>  addBook(<br>    title: &quot;Introdução ao GraphQL: Busca de Dados com Abordagem Declarativa Para Aplicações web Modernas&quot;, <br>    authorId: &quot;2&quot;<br>  ) {<br>    id<br>    title<br>  }<br>}</pre><ul><li>Chamamos a mutation addBook() para a criação de um livro.</li><li>Dentro dos () são informados os argumentos da mutation. Então, as informações que enviaríamos no body de uma chamada POST no REST para a criação de um recurso por exemplo, aqui no GraphQL o envio se dá através de argumentos.</li><li>E, ainda, é possível que você especifique os dados que você quer que sejam retornados no corpo de resposta, id e title, no nosso caso.</li></ul><p>Para operações de atualização e deleção, a estrutura é extremamente similar:</p><ul><li><strong>Atualização</strong></li></ul><pre>mutation {<br>  updateUser(id: &quot;1&quot;, input: { name: &quot;John Doe Updated&quot; }) {<br>    id<br>    name<br>    email<br>  }<br>}</pre><ul><li><strong>Deleção:</strong></li></ul><pre>mutation {<br>  deleteUser(id: &quot;1&quot;) {<br>    id<br>    name<br>  }<br>}</pre><h4>Subscriptions</h4><blockquote>As <strong>Subscriptions</strong> são no <strong>GraphQL</strong> o que os <strong>Sockets</strong> são no <strong>REST</strong></blockquote><p>Elas permitem que os clientes recebam atualizações em tempo real sobre os dados, a partir da ocorrência de um determinado evento por exemplo. Bem à la Socket mesmo gente, logo, se você já está familiarizado com os Soquetes, já dá pra sacar o que está acontecendo aqui. Seu uso é particularmente útil para aplicações que precisam de dados em tempo real, como notificações, atualizações de status ou dashboards:</p><pre>subscription {<br>  bookAdded {<br>    id<br>    title<br>  }<br>}</pre><p>Aqui, ouvimos por eventos bookAdded e, ainda sim — como todo bom GraphQL — selecionamos os dados que são de nosso interesse, id e title nesse caso.</p><p>Agora que passamos por cada conceito singular do GraphQL, esse diagrama vai fazer muito mais sentido na sua cabeça🤯💡:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Zy9-0iLdoyvxX5D0.png" /><figcaption>Imagem retirada dessa documentação: <a href="https://tailcall.run/graphql/schemas-and-types/">https://tailcall.run/graphql/schemas-and-types</a></figcaption></figure><h3>REST x GraphQL</h3><p>Mas afinal: quais suas diferenças?</p><h4>Flexibilidade</h4><p>No REST, cada endpoint retorna uma estrutura de dados fixa. No GraphQL, um único endpoint pode retornar dados diferentes dependendo da query, oferecendo maior flexibilidade para os clientes.</p><h4>Overfetching e Underfetching</h4><p>Um problema comum no REST é o <strong>overfetching</strong> (quando uma resposta inclui mais dados do que o necessário) e o <strong>underfetching</strong> (quando uma resposta não inclui dados suficientes, exigindo chamadas adicionais para a obtenção dos dados por completo, front-ends, se identificaram?). <br>O GraphQL resolve isso permitindo que os clientes especifiquem exatamente quais dados precisam.</p><h4>Performance</h4><p>GraphQL otimiza a performance ao retornar apenas os dados especificados pelo cliente, algo especialmente útil quando se está trabalhando com grandes volumes de dados. Eu mesmo já trabalhei em lugares com dados quiloméééééééééééééééétricos — de transações financeiras por exemplo — e me pego pensando as vezes o quão mais performáticas seriam as consultas a esses dados se o Graph fosse utilizado (apesar de eu entender o porquê do uso não ter sido feito para aquele use-case).</p><h4>Necessidade de BFFs</h4><p>No REST, é comum a criação de Backends For Frontends (BFFs) para atender às necessidades específicas de diferentes clientes (web, mobile, etc.). Com GraphQL, um único back-end pode servir a todos esses clientes, pois cada um deles pode solicitar os dados que forem pertinentes a si.</p><h4>E uma coisa não anula a outra</h4><p>Use a ferramenta certa para o problema certo. O uso combinado de REST e GraphQL na mesma aplicação é perfeitamente possível, extraindo o melhor de cada mundo para construção de nossos projetos da melhor forma.</p><h3>Problemas que o GraphQL resolve</h3><ol><li><strong>Performance:</strong> Como mencionado, o GraphQL retorna apenas os dados necessários para o consumidor, otimizando a performance.</li><li><strong>Implementação de BFFs:</strong> Reduz a necessidade de BFFs, permitindo que um único back-end sirva a múltiplos clientes.</li><li><strong>Documentação automática:</strong> O schema do GraphQL serve como uma documentação viva, facilitando o entendimento da API para novos devs.</li><li><strong>Evolução da API:</strong> É comum enfrentarmos problemas de compatibilidade com o versionamento de APIs REST. Utilizando grafos é possível evoluir a API adicionando novos types e fields sem quebrar a compatibilidade com clientes antigos. Isso te lembra alguma coisa?<br>S<strong>O</strong>LID — Open–closed principle</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*lyq1vQyv7cfsdV41.png" /><figcaption>Imagem retirada desse artigo: <a href="https://www.freecodecamp.org/portuguese/news/os-principios-solid-da-programacao-orientada-a-objetos-explicados-em-bom-portugues/">https://www.freecodecamp.org/portuguese/news/os-principios-solid-da-programacao-orientada-a-objetos-explicados-em-bom-portugues</a></figcaption></figure><h3>Implementações de GraphQL</h3><p>Falamos, falamos e falamos sobre o GraphQL, mas ele é apenas uma <strong>ESPECIFICAÇÃO</strong>, havendo diversas implementações suas para diferentes linguagens e frameworks, tanto no back-end, quanto no front. Do lado das telas, temos como exemplos o <a href="https://the-guild.dev/graphql/apollo-angular/docs"><strong>Apollo</strong></a> para <strong>Angular</strong> e o <a href="https://relay.dev/"><strong>Relay</strong></a> para <strong>React</strong>. Já por trás dos panos, temos o <a href="https://graphql.org/graphql-js/graphql-http"><strong>graphql-http</strong></a> para <strong>Node.js</strong>, que facilita a criação de servidores GraphQL com o Express ou Fastify, por exemplo.</p><h3>Conclusão</h3><p>GraphQL é uma ferramenta poderosa que oferece flexibilidade e eficiência para a construção de APIs modernas. Embora não tenha substituído o REST, é uma alternativa valiosa que resolve problemas comuns de performance e estrutura de dados. Logo, lembre-se: se você está lidando com grandes volumes de dados ou múltiplos clientes, o GraphQL pode ser a solução ideal pra você.</p><h3>Bom, é isso, espero que tenha gostado! E se tiver alguma sugestão deixe aí nos comentários 💬</h3><p>Se gostou, dê 1 ou 50 claps (Só clicar 50x na 👏), ou é 1, ou é 50, não tem meio termo.</p><p><strong>Obrigado pela leitura!</strong></p><p><em>Me acompanhe por aí!</em> 😜</p><ul><li>Portfólio: <a href="https://pedrohlucena.vercel.app/">pedrohlucena.vercel.app</a></li><li>GitHub: <a href="https://github.com/pedrohlucena">@pedrohlucena</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/pedrohlucena1">@pedrohlucena1</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7deb5b2dd64d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Server e Client Components no Next: Uma solução para o excesso de Javascript no browser]]></title>
            <link>https://medium.com/@pedrohlucena/server-e-client-components-no-next-uma-solu%C3%A7%C3%A3o-para-o-excesso-de-javascript-no-browser-0bc67b670f0a?source=rss-feb3e5f03bec------2</link>
            <guid isPermaLink="false">https://medium.com/p/0bc67b670f0a</guid>
            <category><![CDATA[server-components]]></category>
            <category><![CDATA[client-components]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[nextjs]]></category>
            <dc:creator><![CDATA[Pedro Lucena]]></dc:creator>
            <pubDate>Mon, 01 Jul 2024 00:07:12 GMT</pubDate>
            <atom:updated>2024-07-20T18:46:28.440Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7iJKmXacnT1itLHQ" /><figcaption><a href="https://nextjs.org/learn/react-foundations/server-and-client-components">https://nextjs.org/learn/react-foundations/server-and-client-components</a></figcaption></figure><p>O excesso de Javascript no navegador pode ser um verdadeiro pesadelo, especialmente em grandes aplicações. Porém, o Next.js, com sua arquitetura inovadora, oferece uma interessante solução: Server e Client Components. Mas antes de mergulharmos nos detalhes, é importante refletirmos sobre quando e por que usar esse framework, evitando seguir tendências apenas porque estão “no hype”.</p><h4>O que são Server e Client Components?</h4><p>Com a introdução do React 18, o Next.js — a partir da versão 13 — suporta a divisão de componentes em Server e Client Components, através da nova arquitetura do Reaja. Mas o que isso significa na prática?</p><ul><li><strong>Server Components</strong>: São renderizados do lado do servidor e enviados ao cliente como HTML puro. Ao usa-los, nenhum Javascript é enviado ao browser, o que reduz significativamente o tamanho do bundle.</li><li><strong>Client Components</strong>: Ainda são renderizados do lado do servidor inicialmente — diferente do que muita gente pensa — e, quando chegam ao navegador, são hidratados com Javascript e renderizados novamente. Aqui, JS é enviado para o cliente e esses caras são ideais para partes interativas da aplicação que precisam de interatividade e dinamismo⚛.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*m2ghrbqsE66B01LU.png" /><figcaption>Next.js official Docs (beta)</figcaption></figure><p>Ou seja, conseguimos, em uma mesma interface, definir: quais partes enviaremos Javascript pro browser e quais não, otimizando nossas aplicações🚀</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/0*1TUIlbtQmNLbofcG.gif" /></figure><h4>Como isso ajuda a reduzir o excesso de Javascript no browser?</h4><p>Ao fazer uso desses componentes, podemos selecionar a dedo quais partes da nossa aplicação enviarão Javascript ao cliente e quais não, eliminando o JS desnecessário e acelerando o tempo de carregamento da página, abordagem essa que não é possível, por exemplo, em SPAs, onde todo o carregamento da página depende de Javascript. Isso é especialmente benéfico em grandes aplicações, onde cada kilobyte conta.</p><p>Por exemplo, será que o conteúdo de uma página em um blog precisa de Javascript para funcionar? Bem… depende, mas muito provavelmente não. Server Components podem ser utilizados para renderizar esse conteúdo estático e deixar com que o Javascript seja utilizado apenas para partes que de fato precisam de dinamicidade.</p><h4>O hype é caro: Next.js, o custo 💵</h4><p>No entanto, é crucial considerar o custo de usar o Next. Implementar Server e Client Components pode ser caro, tanto no quesito de recursos computacionais, quanto no tempo de desenvolvimento. Por exemplo, em um deploy em cloud AWS, cada server action deve ser configurada como uma Lambda Function. Esse processo pode ser demorado e exigir muita configuração, o que implica em um maior custo operacional. <br>*Obrigado por ter me ensinado isso <a href="https://medium.com/u/ec3f5ba54e80">Vinnicius Gomes</a>❤️</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*0qprvdajVEcmUzb_.gif" /></figure><p>Além disso, a complexidade de deploy de uma aplicação Next.js não pode ser subestimada. Certifique-se de que a sua equipe está preparada pro B.O antes de optar pelo framework.</p><h4>Escolhendo a ferramenta certa🛠️</h4><p>Escolher usar Next.js deve ser uma decisão pautada nas necessidades específicas do seu projeto e não apenas porque é uma tecnologia popular. Analise os requisitos do seu projeto, o custo de implementação e manutenção, e a capacidade da sua equipe. Em alguns casos — pra ser sincero, a maioria deles — uma solução mais simples pode ser mais eficaz e econômica, nessas horas, lembre-se do KISS💋.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*cLWVvezA0xhy5iHo.png" /><figcaption>Imagem retirada do artigo: <a href="https://www.linkedin.com/pulse/should-i-start-business-how-answer-two-stupid-simple-ryan-ensor-mba/">https://www.linkedin.com/pulse/should-i-start-business-how-answer-two-stupid-simple-ryan-ensor-mba</a></figcaption></figure><h4>Seriam os Server Components os componentes do futuro? 🚀</h4><p>A introdução dos Server Components certamente abre novas possibilidades para a otimização de aplicações web. Eles oferecem uma maneira poderosa de reduzir o excesso de Javascript e melhorar a performance das nossas aplicações, o futuro do front-end está caminhando pra isso. Basta pensar que famosos frameworks de performance como Astro, Deno Refresh, entre outros já suportam esses novos tipos de componentes, as <a href="https://docs.astro.build/en/concepts/islands/#what-is-an-island">Astro Islands</a> por exemplo, são, em conceito, client components.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*ckHj0q3sQeFkEQIy.gif" /></figure><h4>Conclusão</h4><p>O Next e a sua nova arquitetura de componentes trazem grandes benefícios, especialmente em termos de performance. No entanto, seu uso deve ser justificado pelo contexto e necessidades do seu projeto, e não apenas porque é uma tecnologia popular. Avalie cuidadosamente os custos e benefícios antes de tomar uma decisão, SEMPRE.</p><h4>Bom, é isso, espero que tenha gostado! E se tiver alguma sugestão deixe aí nos comentários 💬</h4><p>Se gostou, dê 1 ou 50 claps (Só clicar 50x na 👏), ou é 1, ou é 50, não tem meio termo.</p><p><strong>Obrigado pela leitura!</strong></p><p><em>Me acompanhe por aí!</em> 😜</p><ul><li>Portfólio: <a href="https://pedrohlucena.vercel.app/">pedrohlucena.vercel.app</a></li><li>GitHub: <a href="https://github.com/pedrohlucena">@pedrohlucena</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/pedrohlucena1">@pedrohlucena1</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0bc67b670f0a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>