<?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 Caique Ribeiro Rodrigues on Medium]]></title>
        <description><![CDATA[Stories by Caique Ribeiro Rodrigues on Medium]]></description>
        <link>https://medium.com/@cribeirorodrigues?source=rss-be3a333b065c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*fGvIEPEUcY9i9XC6doYMyw.png</url>
            <title>Stories by Caique Ribeiro Rodrigues on Medium</title>
            <link>https://medium.com/@cribeirorodrigues?source=rss-be3a333b065c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 22:46:11 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@cribeirorodrigues/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[System Design — Capacity Estimation]]></title>
            <link>https://medium.com/@cribeirorodrigues/system-design-capacity-estimation-a34309f88914?source=rss-be3a333b065c------2</link>
            <guid isPermaLink="false">https://medium.com/p/a34309f88914</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[system-design-interview]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Caique Ribeiro Rodrigues]]></dc:creator>
            <pubDate>Mon, 18 Dec 2023 01:24:08 GMT</pubDate>
            <atom:updated>2023-12-18T17:12:12.594Z</atom:updated>
            <content:encoded><![CDATA[<h3>System Design — Capacity Estimation</h3><p>An interesting additional feature to make your system design richer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wmX1CiwRG78rlE5pAY7hmg.png" /></figure><p>System design is a topic that shows up on the path of every developer who’s moving forward (or at least trying) to the next level. It’s not just about coding, you’ve got to design the infrastructure and integrations between systems at higher levels. You should be an architect, not just an executor.</p><p>In a system design, nothing can be left to chance. When choosing a database, you need to justify the reasons and the tradeoffs. Chosen for AWS EKS instead of an EC2? Explain yourself. Using a lambda function? Well, just explain it. Everything should be thought through realistically because this stage is crucial for your system’s performance, determining whether it can handle all the requests needed and if its cost will be as minimal as possible (you know, in the end, it’s all about the money).</p><p>One detail in this beautiful practice that often goes unnoticed in some designs is the capacity estimation. Since it’s not a mandatory topic in smaller companies or entry-level job interviews, capacity estimation is sometimes treated like a distant cousin you only hear about occasionally.</p><p>These calculations aim to seek indicators of the number of requests, bandwidth, throughput, and storage over a specific period. These calculations play a crucial role in some subsequent modeling decisions:</p><ul><li>Choosing the database and storage size</li><li>Clustering and/or load balancing</li><li>Caching</li></ul><p>The key in this process is not to aim for complete accuracy but to use guidelines to get close and calculate values more rapidly.</p><h3><strong>Scientific Notation</strong></h3><p>In capacity estimates, it’s common to use scientific notation. Working with calculations in this format makes the process much simpler and quicker than dealing with thousands of zeros in a high-pressure situation. Remember: Precision here is unnecessary; approximation is more than enough.</p><p>Some examples of useful notations do keep in mind are:<br>1000 = 10ˆ3<br>10000 = 10ˆ4<br>100000 = 10ˆ5<br>7.000 = 7*10ˆ3<br>95.00 = 95*10ˆ3 (or9.5*10ˆ4)</p><p>Moreover, some conversions work like magic:<br><strong>KB → MB</strong> = KB/10^3<br><strong>MB → GB</strong> = MB/10^3 <br><strong>GB → TB</strong> = GB/10^3<br><strong>MB → TB</strong> = MB/10^6</p><blockquote><em>To make it easier, remember a trick: The exponent will be the number of zeros to the right. 1000 will be 10³, for example.</em></blockquote><h3>Most common calculations</h3><p>In a system design, a lot of calculations may be necessary to achieve your goals. Indeed, there are some kind of them that appear almost every time and probably will be the only ones you’ll need in 90% of time.</p><h4>Requests per second</h4><p><strong>DAU / 10⁵</strong></p><p>Let’s delve deeper into this.</p><p><strong>DAU</strong> means <strong>Daily Active Users</strong>, in other words, how many users access the platform in a day multiplied by the amount of request each one does. 10⁵ is just the quantity of seconds in a day.</p><p>Here’s an example:<br><em>1.000.000 users.<br>5 requests per day (each user)<br>5.000.000 requests per day.</em></p><p><strong>First of all, let’s calculate seconds in a day<br></strong>24 <em>(hours)</em> * 60 <em>(minutes)</em> * 60 <em>(seconds)</em> = 86.400 seconds. Rounding it, you could just consider 100.000 seconds. Using scientific notation you’ll get 10⁵.</p><p><strong>Applying the formula<br></strong>Now we know we have 10⁵ seconds in a day and 5.000.000 requests per day. As I said before, this kind of calculations is way easier to do with all elements in scientific notation, so you just have to convert 5.000.000 in it. One million in scientific notation is 10⁶, so all you have to do is multiply it by 5 and get 5*10⁶.</p><p>With it in hand, calculate the formula:<br>5*10⁶ / 10⁵<br>5*10^(6–5)​ <br>5*10<br><strong>50 requests per second (RPS).</strong></p><p>Using the formula you could calculate that your API will receive <strong>50 RPS</strong>.</p><h4>Bandwidth per second</h4><p>Bandwith is the amount of data transfered in a request. Knowing the amount of bandwith per second is crucial to better think about how you will design you system. Calculate it is very simple:</p><p><strong>Requests per second (RPS) / Request size</strong></p><p>Of course it will be impossible to predict the exactly amount of all requests in your system, but calculating one (normally the most important in the context) will be enough. Remember, you just have to show that you are not building software from imagination.</p><p>Calculate a request size requires knowing the size of JSON/XML/Plain Text you are receiving and some more complex stuff in the HTTP request, so for now let’s just assume each request is 50 KB.</p><p><strong>50 (RPS) * 50 KB = 2500 KB per second (2500 KB/s)</strong></p><p>You can transform KB in MB using one of the tricks I showed at the beginning. 2500 in scientific notation is 2.5 * 10³:</p><p><strong>2.5 * 10³ / 10³ <br>2.5 * 10⁰ <br>2.5 * 1 ⇒ 2.5MB/s​</strong></p><h4>Storage per second</h4><p>The last of most common calculation is the storage. I will show it per second, but in many cases it will be required to be done per year or each 5 years.</p><p>To calculate it you just have to multiply the amount of writes per second by the size of the request. Remember the RPS we’ve just calculated? Let’s use it now. Imagine that, for that 50 RPS, the proportion is 9:1 (9 reads and 1 write). Doing a quick math, we’ll have:</p><p>writes = 50 rps / 10 <em>(10 percent)</em> = 5 rps<br>reads = 45rps <em>(50 total –5 writes)</em></p><p>Ok, now assume each write request will store 50 KB in database and apply everything in the following formula.</p><p><strong>RPS * Request Size</strong></p><p>5 rps * 50 KB/s = 250 KB/s, or 0.25 MB/s</p><p>You just calculated the storage needed per second. It is not actually so useful, but you can use it to calculate other periods, like day and month.</p><p>An example can be storage per day:</p><p><strong>storage por sec * 10⁵</strong> <br><strong>0.25 * 10⁵<br>25 GB per day</strong></p><p>Good! These are all the knowledge you will need to increase your system design. Do not forget that System Design is more about if you are able to make good questions and think about saving resources than how to build a complex architecture.</p><p>Hope you like it! See you soon.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a34309f88914" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[EN] Typescript Basics: 1 —  Inferences]]></title>
            <link>https://medium.com/@cribeirorodrigues/en-typescript-basics-1-inferences-55e6785f9e74?source=rss-be3a333b065c------2</link>
            <guid isPermaLink="false">https://medium.com/p/55e6785f9e74</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Caique Ribeiro Rodrigues]]></dc:creator>
            <pubDate>Sun, 30 Jul 2023 15:00:48 GMT</pubDate>
            <atom:updated>2023-07-30T15:17:29.040Z</atom:updated>
            <content:encoded><![CDATA[<h3>[EN] Typescript Basics: 1. Inferences</h3><p>1 — How to extract basic types from variables and functions</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*-HxELkhJNVLosXR13CjX2w.jpeg" /></figure><p>Typescript is a powerful programming language. Built on top of Javascript, it solves most of problems of its mother language, giving developers almost all the powers of a typed OOP language such as Java and C#, at the same time that allows easy and dinamic programming style of Javascript.</p><p>Despite it, most of developers don’t know 10% of TS funcionalities, making them think our beloved language is too basic to more complex applications. To mitigate this percentage, this article will show some basic type inferences we can do with Typescript funcionalities and might be helpful for you.</p><h4>The typeof keyword</h4><p>The typeof keyword is a really simple tool that allows us to explicit get the type(s) of a code block, being it a string, number, object, function or anything else. It’s used when you want to get type of something to, for instance, create another code snippet that receives that type as an input.</p><pre>const myName = &#39;Caique&#39;<br>type VariableType = typeof myName // this type will be &#39;string&#39;</pre><h4>The keyof keyord</h4><p>Another simple keyword used a lot is keyof. This tool gets the keys of an object and converts it into a type. The most ordinary use of it is when we’re in a loop (forEach, map, reduce, filter, etc) and want to let TS know the current item key is the same type`of the general object key. Here’s an example:</p><pre>const bestOfTypescript = {<br> database: &#39;Prisma&#39;,<br> frontend: &#39;ReactJS&#39;,<br> backend: &#39;NodeJS&#39;<br>}<br><br>// It will loop through all the object keys (database, frontend, backend)<br>Object.keys(bestOfTypescript).forEach(key =&gt; {<br> /* <br> Error shown: Element implicity has an &#39;any&#39; type because expression of type &#39;string&#39;<br> can&#39;t be used to index type &#39;{ database: string; frontend: string; backend: string }&#39;.<br> */<br>  console.log(bestOfTypescript[key])<br>})<br><br>// To fix it, keyof could be used:<br>const bestOfTypescript = {<br> database: &#39;Prisma&#39;,<br> frontend: &#39;ReactJS&#39;,<br> backend: &#39;NodeJS&#39;<br>}<br><br>type BestOfTypescript = typeof bestOfTypescript // type extracted just to be clearer<br><br>Object.keys(bestOfTypescript).forEach(key =&gt; {<br>  console.log(bestOfTypescript[key as keyof BestOfTypescript])<br>})</pre><h3>Inference Basics</h3><p>Knowing that, I’ll show some tricks you can use combining keyof, typeof and a bunch of TS Utility Types to inference types in your code.</p><h4>Get the return type of a function</h4><p>Any function has a return (event if it’s just void), and sometimes you’ll want to get this return type to use it as a parameter to another function or to mount a new type. You can do it easily using the typeofand the utility ReturnType.</p><pre>export function formatDateToObject(date: Date) {<br>  const dateObject = {<br>    fullDate: new Intl.DateTimeFormat(&#39;pt-BR&#39;, {<br>      year: &#39;numeric&#39;,<br>      month: &#39;2-digit&#39;,<br>      day: &#39;2-digit&#39;,<br>    }).format(date),<br><br>    year: new Intl.DateTimeFormat(&#39;pt-BR&#39;, {<br>      year: &#39;numeric&#39;,<br>    }).format(date),<br><br>    dateAndMonth: new Intl.DateTimeFormat(&#39;pt-BR&#39;, {<br>      month: &#39;2-digit&#39;,<br>      day: &#39;2-digit&#39;,<br>    }).format(date),<br><br>    hour: new Intl.DateTimeFormat(&#39;pt-BR&#39;, {<br>      hour: &#39;2-digit&#39;,<br>      minute: &#39;2-digit&#39;,<br>    }).format(date),<br>  };<br><br>  return dateObject<br>}<br><br>type FormatDateToObjectType = ReturnType&lt;typeof formatDateToObject&gt;<br><br>/*<br>It will result in:<br>  type FormatDateToObjectType = {<br>      fullDate: string;<br>      year: string;<br>      dateAndMonth: string;<br>      hour: string;<br>  }<br>*/</pre><h4>Get the return type of an async function</h4><p>As well as getting return type of a simple function, it’s natural you would like to get the return of an async function (in other words, that returns a Promise.). To do that, you just need to add one more utility type: Awaited.</p><pre>async function sayMyInformations(name: string, age: number) {<br>  return `My name is ${name} and I have ${age} years old`<br>}<br><br>type ReturnValue = Awaited&lt;ReturnType&lt;typeof myFunc&gt;&gt;<br><br>/*<br>It will result in:<br>  type ReturnValue = string<br>*/</pre><h4>Get the function parameters</h4><p>Really similar to getting return type, it’s possible to use typeof and Parameters to retrieve the parameters types of any function.</p><pre>function sayMyInformations(name: string, age: number) {<br>  return `My name is ${name} and I have ${age} years old`<br>}<br><br>type FunctionParameters = Parameters&lt;typeof sayMyInformations&gt;<br><br>/*<br>It will result in:<br>  type FunctionParameters = [name: string, age: number]<br>*/</pre><h4>Using object keys to generate Union Types</h4><p>Union Type is a type that can have more than one information. It can be a number OR a string OR a boolean, or it can be a list of string, such as database OR frontend OR backend . It means that any of the informations will be accepted as valid. In Typescript notation, it will be like this: optionOne | optionTwo | optionThree</p><p>Sometimes it’s desired to make a type that contains all the keys of an object to use it as part of a more complex type, or to infer it in a function parameter. Whatever your need, it’s possible to get this result using a simple combination of keyof and typeof.</p><pre>const bestOfTypescript = {<br>  database: {<br>    prisma: true,<br>    mongoose: true,<br>    firebase: false,<br>  },<br>  frontend: {<br>    reactjs: true,<br>    nextjs: true,<br>    vue: false,<br>  },<br>  backend: {<br>    nodejs: true,<br>    nestjs: true,<br>  }<br>}<br><br>type BestOfTypescriptTypes = typeof bestOfTypescript<br>type BestOfTypescriptKeysTypes = keyof BestOfTypescriptTypes<br><br>/*<br>It will result in:<br>  type BestOfTypescriptKeysTypes = &quot;database&quot; | &quot;frontend&quot; | &quot;backend&quot;<br>*/</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55e6785f9e74" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introdução ao Apache Kafka (para humanos) — Parte 2]]></title>
            <link>https://medium.com/@cribeirorodrigues/introdu%C3%A7%C3%A3o-ao-apache-kafka-para-humanos-parte-2-3c1712147a1?source=rss-be3a333b065c------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c1712147a1</guid>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[apache-kafka]]></category>
            <category><![CDATA[messaging]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <dc:creator><![CDATA[Caique Ribeiro Rodrigues]]></dc:creator>
            <pubDate>Sat, 18 Sep 2021 01:44:47 GMT</pubDate>
            <atom:updated>2021-09-18T01:49:09.342Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introdução ao Apache Kafka (para humanos) — Parte 2</h3><p>Parte 2 — Partições</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-hMjNt5xR2aAzazGLjWjbg.jpeg" /></figure><p>Na <a href="https://medium.com/@cribeirorodrigues/introdu%C3%A7%C3%A3o-ao-apache-kafka-para-humanos-parte-1-ab441c7c88dc">Parte 1</a> falamos sobre o funcionamento geral do Kafka, e como um Produtor se comunica enviando uma mensagem (registro) para um tópico, para que qualquer Consumidor deste tópico possa ter acesso à informação.</p><p>Porém, os registros enviados para um tópico não ficam todos juntos, eles são separados em grupos chamados de <strong>partições</strong>. As partições separam várias mensagens em porções menores, mas todos pertencentes ao mesmo tópico, sendo que <strong>cada registro só vai para uma única partição</strong>. Pense no tópico como um armário e nas partições como as gavetas desse armário.</p><p>Mas qual a finalidade disso?</p><h3>Partições</h3><blockquote>Cada tópico possui uma ou mais partições para garantir a distribuição e resiliência dos dados enviados para ele.</blockquote><p>Quando um registro chega em um tópico, o Kafka decide “aleatoriamente” para qual partição esse registro será alocado. Os consumidores que lerem de determinada Partição A irão ler as mensagens X, enquanto consumidores que estão lendo da Partição B lerão as mensagens Y.</p><p>Cada partição de um tópico fica alocada em um <em>Broker</em> (uma máquina independente no <em>cluster</em> do Kafka). A <strong>Partição A</strong> pode ficar no <strong><em>Broker</em> 1</strong>, a <strong>Partição B</strong> no <strong><em>Broker</em> 2</strong>, e assim por diante. Os registros enviados ao tópico ficam então <strong>separados </strong>entre as máquinas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3qkls-TTtxHcTUnERjSJZg.png" /><figcaption>Duas mensagens indo para o mesmo tópico caem em partições diferentes.</figcaption></figure><p><em>(Caso você tenha pensado “E como ficam os offsets?”: Cada partição separa os registros em offsets próprios. A partição 1 pode ter registros em offsets do 0 ao 10 e a partição 2, offsets de 0 a 12 de forma independente.)</em></p><p>Isso leva a duas vantagens:</p><ol><li>Resiliência — Se todos os registros de um tópico estivessem em um mesma máquina, caso a máquina ficasse indisponível, todos os registros do tópico ficariam também indisponíveis. Com a distribuição dos registros entre máquinas diferentes, parte dos registros ainda estariam disponíveis para serem processados.</li><li>Velocidade — Imagine que você tem 1000 registros sobre envio de <em>e-mail</em> em um Tópico e um consumidor leva 30 minutos para processar esses registros e enviar os 1000 <em>e-mails</em>. Caso esse consumidor esteja em um serviço distribuído com 2 nós, ele poderia ler estes registros e enviar os <em>e-mails</em> em metade do tempo. Mas, estando todas as informações juntas, como seria possível garantir que o registro lido por um nó já não tenha sido lido por outro? Com a separação de partições, cada nó pode ler uma partição com a certeza de que os registros ali não estão em outro lugar.</li></ol><h4>Garantindo a ordem de entrega</h4><p>A abordagem de separação por partições funciona muito bem quando pensamos em registros que são independentes uns dos outros, mas quando o cenário exige que as eles sejam dependentes, temos um problema gravíssimo: como vou garantir a ordem correta?</p><p>Imagine a seguinte situação: os registros do tópico são referentes a compras no cartão de crédito. Existem duas partições, que estão sendo lidas cada uma por um nó da aplicação que processa a compra. O primeiro registro (A) é o pedido da Compra 1, o próximo (B) é uma segunda compra . Por algum motivo a primeira compra precisou ser cancelada, então foi enviado um terceiro registro (C) referente ao cancelamento dela.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/914/1*AMzDGlMDD872RJyohpOxpQ.png" /><figcaption>A mensagem de cancelamento caiu em uma partição diferente da confirmação de compra</figcaption></figure><p>Enquanto o registro de confirmação da Compra 1 caiu no <em>offset 0</em> da primeira partição, o cancelamento caiu no <em>offset 0</em> da <em>segunda partição</em>. É fácil perceber que isso pode causar um problema muito grande caso o Consumidor 2 processe o registro do cancelamento <strong>ANTES</strong> do Consumidor 1 conseguir processar o de confirmação. Essa possibilidade aumenta caso, por algum motivo, o Consumidor 1 esteja lento e o Consumidor 2 esteja rápido.</p><h4>Keys</h4><p>O ideal seria que, caso exista um dependência entre registros, pudéssemos garantir que estes fossem lidos sempre na ordem correta. Sabendo que um consumidor naturalmente lê os <em>offsets</em> em sequência (<em>offset</em> 0, 1, 2, 3…), se for possível enviar registros interdependentes para a mesma partição, o caso estará resolvido. É aí que entram as <em>keys</em>.</p><p>Falei na Parte 1 que os registros, além da mensagem transmitida, podem ter headers, timestamp e <strong><em>keys, </em></strong>e estas keys são as responsáveis por dizer que mensagens <strong>devem ir para a mesma partição</strong>. O Kafka <strong>sempre vai garantir</strong> que todos os registros que possuirem a key compra-1 (o nome é livre) irão cair na mesma partição.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/902/1*80oHk1-f4UkIbujt5taZWQ.png" /><figcaption>Registros com a mesma key sempre caem na mesma partição.</figcaption></figure><h4>Resiliência de dados e Partições Distribuídas</h4><p>Você já sabe que as partições são separadas entre os <em>Brokers</em>, de forma que ficam em uma estrutura parecida com essa*:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*bzSeSYnUu8Zmw_HCLcflRg.png" /><figcaption>* Não necesariamente a Partição 1 ficará no Broker 1, a 2 no Broker 2, e assim por diante.</figcaption></figure><p>Quando expliquei isso, disse que uma das vantagens é que, caso um dos <em>Brokers</em> fique indisponível, apenas os registros da partição que ele guarda serão perdidos, e não todos. Esse cenário é bom, mas ainda não é o ideal e, de fato, não é assim que normalmente se trabalha com partições distribuídas entre <em>Brokers</em>.</p><p>Na vida real com Kafka, sempre queremos que sejam criadas cópias de todas as partições e elas sejam distribuídas entre os brokers. Essa configuração se chama <em>replication factor</em>. Caso seu cluster tenha como configuração o replication-factor=2 cada uma de suas partições terá uma cópia que ficará em um Broker diferente da original. A estrutura fica assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*2Nel10lkiSqci3fuTN6aCg.png" /><figcaption>3 partições — 3 Brokers — replication-factor=2</figcaption></figure><p>Isso diminui muito a possibilidade da alguma informação ser perdida. No exemplo acima, caso o <em>Broker</em> 1 caia, os Consumidores que estão lendo da Partição 1 são redirecionados para o <em>Broker</em> 3 automaticamente pelo Kafka. Quanto maior a quantidade de <em>Brokers</em> e <em>replication factor</em>, maior a resiliência dos dados (porém maior o consumo dos recursos do Broker).</p><p>Partition Leadership</p><p>As partições que possuem réplicas espalhadas entre os Brokers são separadas em partições líderes (leaders) e partições seguidoras (<em>followers</em>) e em um cenário mais simples uma das réplicas será a leader e todas as outras serão as followers. Sabendo isso, existe uma regra absoluta quando se fala em leitura de partições distribuídas:</p><p><strong>Um Consumidor que precisa ler uma partição SEMPRE vai ler da <em>leader</em>, nunca das <em>followers</em>.</strong></p><p>As partições followers servem como backup. Apenas.</p><p>Caso o Broker com a partição leader caia, o Kafka automaticamente nomeia uma das réplicas restantes como <em>leader</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*LfY2eKXtIdL3uuHYjDAZ9Q.png" /><figcaption>No exemplo cada tópico tem uma partição líder</figcaption></figure><p>No exemplo acima, existem duas instâncias de cada uma das partições, mas apenas uma <em>leader</em> de cada. Tudo funcionando tranquilamente. Consumidores da Partição 1 irão ler sempre do <em>Broker</em> 1, consumidores da Partição 2 sempre do <em>Broker</em> 2 e quem ler da partição 3… Deu pra entender.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/882/1*KbzEMRfY4uSWDta4GfyBXQ.png" /><figcaption>Ao cair um Broker com partição leader, outro broker toma essa responsabilidade</figcaption></figure><p>Em dado momento o <em>Broker</em> 1 cai. Aconexão é perdida, o disco rígido é corrompido, a máquina pegou fogo… Por qualquer que seja o motivo, ao perceber que a Partição 1 <em>leader</em> não está mais disponível, o Kafka nomeia uma outra réplica, no caso, no <em>Broker</em> 3, como <em>leader</em> e todos os Consumidores da Partição 1 começam a ler desta réplica.</p><h3>Finalizando</h3><p>Esta segunda parte ficou consideravelmente mais densa do que a primeira e talvez você precisa ler algumas vezes para entender a lógica de tudo isso. Mas fique tranquilo. Esses conceitos são, apesar de básicos, alguns dos mais complicados do Kafka. Entendendo todos eles, o caminho será muito mais fácil. As partições e sua arquitetura são o grande diferencial do Apache Kafka e na Parte 4 vamos ver como elas são maravilhosas na prática. :)</p><p>No post seguinte falaremos do último conceito básico do Kafka:<em> Consumer Group</em>s. Será uma seção menor e provavelmente com um conceito mais simples de entender.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c1712147a1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introdução ao Apache Kafka (para humanos) — Parte 1]]></title>
            <link>https://medium.com/@cribeirorodrigues/introdu%C3%A7%C3%A3o-ao-apache-kafka-para-humanos-parte-1-ab441c7c88dc?source=rss-be3a333b065c------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab441c7c88dc</guid>
            <category><![CDATA[iniciante]]></category>
            <category><![CDATA[apache-kafka]]></category>
            <category><![CDATA[microsserviços]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <category><![CDATA[messaging]]></category>
            <dc:creator><![CDATA[Caique Ribeiro Rodrigues]]></dc:creator>
            <pubDate>Tue, 14 Sep 2021 21:01:54 GMT</pubDate>
            <atom:updated>2021-09-18T01:50:18.700Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introdução ao Apache Kafka (para humanos) — Parte 1</h3><h4>Parte 1 — Para que serve o Kafka e qual seu funcionamento</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RWCcZyUH9uAhUsigBJnxjA.jpeg" /><figcaption>Photo by greenleaf123 on iStockphoto</figcaption></figure><p>Com o passar do tempo na carreira de desenvolvedor surgem gradualmente algumas necessidades que, nos desafios do início da carreira, não passam sequer pela imaginação. Ao fazer o primeiro <em>Hello World</em> não imaginamos que precisamos salvar dados em disco (banco de dados, arquivos, etc); quando começamos a brincar com SQL, não sabemos para que usar a Orientação Objetos e ao usar a POO, provavelmente não temos a mínima ideia do que seja criptografia simétrica e assimétrica.</p><p>Com esse avanço gradual, chega-se em um momento onde nossas aplicações precisam de duas qualidades: <strong>segurança de entrega de dados </strong>e o que vou chamar aqui de <strong>processamento preguiçoso </strong>(para ficar mais fácil de entender e também porque achei um termo legal).</p><h4>Segurança de Entrega e Processamento Preguiçoso</h4><p>Imagine que você tem um <em>e-commerce</em> e ele funciona a partir de 2 serviços: o primeiro, de compra, e o segundo, de processar pagamentos. Você faz uma <em>Black Friday</em> e a quantidade acesso à página de vendas sobe muitas vezes. Porém, no outro dia, nos seus <em>Analytics</em> você percebe que metade das vendas deram errado pois, ao enviar os dados de pagamento, ocorreu um erro e a venda foi negada. Nisso muitos clientes desistiram e você perdeu metade do seu possível faturamento.</p><p>Em uma análise técnica você percebeu que isso aconteceu porque o envio de mensagens era tão alto que seu sistema de processar pagamentos não aguentou e caiu, assim o serviço de compras recebia um erro e não continuava a operação. Você poderia ter ficado rico. :(</p><p>Você consegue visualizar que, neste caso, o ideal seria que o serviço de vendas não fosse totalmente dependente do processamento de pagamento, pois não há necessidade da aprovação ser feita no exato momento da requisição? Isso pode esperar alguns segundos ou até um pouco mais (e notificar o usuário por e-mail, por exemplo, de que a compra foi aprovada). Neste caso, o serviço de processamento também não tem a necessidade de validar aquela compra exatamente na hora em que ela foi feita, mas sim quando ele <strong>quiser</strong> (quiser = estiver disponível). É preciso então uma estratégia para que os serviços não sejam totalmente dependentes, mas que haja uma <strong>garantia</strong> de que os dados entre eles <strong>não sejam perdidos</strong>.</p><h3>O que é o Apache Kafka?</h3><p>O Kafka é uma plataforma distribuída de <em>streaming</em> de eventos para <em>pipeline</em> de dados, integração de dados e aplicações de missão críticas. O que quer dizer, em linguagem de humano, que ele é um “interceptador” de mensagens entre sistemas, guardando as mensagens recebidas de um serviço e disponibilizando para outro(s) de forma assíncrona, ou seja, os serviços <strong>consumidores</strong> (guarde a palavra) podem resgatar os dados <strong>a qualquer momento</strong>, e não necessariamente quando o <strong>produtor</strong> (essa também) da mensagem enviar. Ele faz o papel dos Correios. O vendedor não envia o produto direto para sua casa, ele manda para alguma unidade do Correios e informa quem deve receber a encomenda.</p><p><em>Uma analogia: A comunicação entre serviços tradicional é simular a uma ligação, enquanto a comunicação usando o Kafka é simular a uma mensagem no WhatsApp (reflita o porquê).</em></p><h3>Funcionamento Básico</h3><p>Funciona assim:</p><ol><li>Um sistema produtor manda uma mensagem para o Kafka, informando qual o “contexto” da mensagem, o que, no Kafka, chama-se <strong>tópico</strong>.</li><li>O Kafka recebe a mensagem e guarda no tópico informado, permitindo que um ou mais sistemas consumidores possam ler essa mensagem.</li><li>Os consumidores acessam o tópico e leem a mensagem desejada. Um tópico pode ter várias mensagem, então os consumidores podem ler todas elas.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/783/1*RPxbTFy--AbywfGddtt8Nw.png" /><figcaption>Fluxo básico de Produtor(producer) — Kafka — Consumidor(consumer)</figcaption></figure><p>Na imagem acima, o <em>Broker</em> representa uma máquina executando um nó do serviço. É importante guardar esse conceito pois é possível rodar vários Brokers em paralelo para formar um <strong><em>Kafka Cluster</em></strong>, o que permite que tenhamos muitos tópicos e uma boa redundância para que os dados não sejam perdidos (isso vai ser abordado na <strong>parte 2</strong>).</p><p><em>Mesmo a figura apontando para uma comunicação unidirecional, é possível que um consumidor de um tópico seja produtor em outro e vice-versa.</em></p><h4>Tópicos</h4><blockquote>Um tópico é o canal de comunicação responsável por receber e disponibilizar os dados enviados para o Kafka.</blockquote><p>Para comunicar-se com o Kafka é obrigatório que a mensagem seja enviada à um tópico. É com ele que produtores e consumidores sabem que estão “na mesma conversa”.</p><p>Um tópico funciona como um <em>log</em>, logo cada mensagem enviada é armazenada uma atrás da outra e identificada por um <em>offset</em>, que é a posição onde ela se encontra no tópico. Essa estratégia permite que vários consumidores possam estar lendo mensagens diferentes no mesmo momento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PiTOdiJNRwffuc5FOpJnHg.png" /></figure><p>Enquanto um Produtor pode estar enviando uma mensagem que será indexada no <em>offset</em> 12, um certo Consumidor pode estar lendo a mensagem do <em>offset</em> 9, outro uma mensagem do <em>offset</em> 10, 11 e assim por diante. Os consumidores também podem revisitar mensagens de <em>offsets</em> anteriores no momento que quiserem.</p><h4>Registros</h4><p>As mensagens que enviamos são chamadas de registros no ecossistema do Kafka. Os registros tem uma anatomia que permite que o manipulemos de forma eficiente. Um registro possui:</p><p><strong>Headers </strong>— Metadados que podem ser eventualmente passados<br><strong>Key </strong>— Auxilia para a definição do contexto da mensagem e é crucial caso você queira garantir que vários registros sejam lidos em uma <strong>ordem específica</strong> (falarei mais na parte 2).<br><strong>Value </strong>— É o valor da mensagem, o conteúdo que queremos transmitir. (alguns chamam de <em>payload</em>).<br><strong>Timestamp</strong> — O momento em que a mensagem foi passada.</p><p>Só falta um conceito para que você possa dizer que sabe o básico do básico do Kafka, que são as <strong>Partições</strong>. Porém, como o assunto é um pouco extenso, vou abordá-lo na Parte 2.</p><p>É isso aí, essa foi a primeira parte da Introdução ao Kafka para quem não sabe nada de mensageria. Essa introdução está planejada para ter 4 partes e na <strong>Parte 2</strong> vou falar um pouco sobre <strong>Partições</strong> e<strong> como garantir a ordem de entrega</strong> usandos as <em>keys</em> dos registros.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab441c7c88dc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[E-mail + Background jobs no NodeJS]]></title>
            <link>https://medium.com/@cribeirorodrigues/e-mail-background-jobs-no-nodejs-9e6d959e787f?source=rss-be3a333b065c------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e6d959e787f</guid>
            <category><![CDATA[nodemailer]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[background-jobs]]></category>
            <dc:creator><![CDATA[Caique Ribeiro Rodrigues]]></dc:creator>
            <pubDate>Thu, 02 Jul 2020 16:38:49 GMT</pubDate>
            <atom:updated>2020-07-02T16:38:49.842Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*HESUIsRwrt55ew5W_2XxEw.png" /></figure><p>Parte 2: Configurando templates de e-mail</p><p>Depois de um tempo, vamos continuar com o processo de envio de e-mail. Agora vamos configurar um template.</p><p>Atualmente, nossa aplicação envia e-mails sem formatação nenhuma. Um texto puro. Mas com a criação de templates podemos estilizar as coisas de acordo com nossa vontade. Para isso vamos usar as dependências que instalamos na primeira parte: express-handlebars e nodemailer-express-handlebars. Elas são responsáveis por permitir a estilização dos emails no nodemailer.</p><h3><strong>Criando os arquivos de template</strong></h3><p>Precisamos criar toda a configuração dos layouts. Normalmente crio uma estrutura views/emails/layouts dentro da pasta app. Nela, vamos criar o arquivo default.hbs. Arquivos de extensão handlebars vão servir para criarmos os layouts.</p><pre>&lt;div style=”font-family: Arial, Helvetica, sans-serif; font-size: 16px; line-height: 1.6; color: #222; max-width:600px”&gt;{{{ body }}}{{&gt; footer }}&lt;/div&gt;</pre><p>Foi criada uma div com estilização inline (pode ser qualquer estilização) e dentro dela, usamos uma tag {{{ body }}} que irá englobar todos os dados que enviaremos no e-mail. Para quem já usa React, é como uma propriedade passado para um componente.</p><p>Depois veio o {{{ &gt; footer }}} que tem a mesma finalidade, porém usando o caractere <strong>&gt;</strong> para que o layout entenda que se trata de um <strong>partial</strong>. Um partial é uma parte separada do layout que pode ser desenvolvida e estilizada separadamente. No caso, será um footer.</p><h3><strong>Criando o footer</strong></h3><p>É possível criar componentes separados e juntá-los no layout principal, o que ajuda na organização e reaproveitamento do código. Esses componentes são chamados de partials. Para criarmos um partial de footer, iremos criar uma pasta chamada partials em views/emails e depois o arquivo footer.hbs.</p><pre>&lt;br /&gt;<br>Um footer muito top</pre><p>Só isso. Você pode colocar muito mais coisa, mas a intenção aqui não é o código e sim a estrutura, né? Agora vamos criar o corpo do email. O corpo será aquela tag {{{ body }}} que estava no layout e receberá diretamente os dados que passaremos ao enviar um e-mail pelo controller que fizemos.</p><p>Crie um arquivo com o nome desejado na pasta views/emails. O meu vai ser cancellation.hbs para simular um envio de cancelamento.</p><pre>&lt;strong&gt;Olá, {{ provider }}&lt;/strong&gt;<br>&lt;p&gt;Houve um cancelamento de horário. Confira os detalhes abaixo&lt;/p&gt;&lt;p&gt;<br>&lt;strong&gt;Cliente:&lt;/strong&gt; {{ user }} &lt;br /&gt;     &lt;strong&gt;Data/hora&lt;/strong&gt; {{ date }} &lt;br /&gt;<br>&lt;br /&gt;<br>&lt;small&gt;O horário está novamente disponível para novos agendamentos.&lt;/small&gt;<br>&lt;/p&gt;</pre><p>Beleza, tudo certo com o template. Agora precisamos dizer para a aplicação que, quando formos enviar um e-mail, precisamos usar essa coisa toda que fizemos.</p><h3><strong>Configurando o Mail.js</strong></h3><p>Lá, no arquivo Mail.js, que é onde temos as funcionalidades de envio, precisamos colocar mais algumas coisas. A primeira é importar as dependências do express-handlebars e nodemailer-express-handlebars. Ah, e o resolve da biblioteca path também, para podermos informar os caminhos das pastas.</p><pre>import nodemailer from ‘nodemailer’;<br>import exphbs from ‘express-handlebars’;<br>import nodemailerhbs from ‘nodemailer-express-handlebars’;<br>import { resolve } from ‘path’;<br>import mailConfig from ‘../configs/mail’;</pre><p>Depois, devemos criar uma função de configuração de template</p><pre>configureTemplates() {<br> const viewPath = resolve(__dirname, ‘..’, ‘app’, ‘views’, ‘emails’);</pre><pre> this.transporter.use(<br>   ‘compile’,<br>   nodemailerhbs({<br>     viewEngine: exphbs.create({<br>      layoutsDir: resolve(viewPath, ‘layouts’),<br>      partialsDir: resolve(viewPath, ‘partials’),<br>      defaultLayout: ‘default’,<br>      extname: ‘.hbs’,<br>     }),<br>    viewPath,<br>    extName: ‘.hbs’,<br>   })<br>  );<br> }</pre><p>na variável viewPath foi configurada a pasta base onde as configurações do template ficarão, então usando o this.transporter feito na primeira parte, usamos a função use para informar que iremos compilar os emails com o nodemailerhbs e, dentro dele, configuramos a pasta onde estão os layouts e os partials, além de informar que o layout padrão (defaultLayout) é o default.hbs e o a extensão padrão dos arquivos é .hbs.</p><p>Depois disso, no construtor desta classe Mail.js precisamos invocar esse método a partir de this.configureTemplates(), então colocamos isso logo depois de criar o transporter.</p><pre>class Mail {<br> constructor() {<br>  const { host, port, secure, auth } = mailConfig;</pre><pre><em>  this</em>.transporter = nodemailer.createTransport({<br>   host,<br>   port,<br>   secure,<br>   auth: auth.user ? auth : null,<br>});</pre><pre><em>  this</em>.configureTemplates();</pre><pre>}</pre><p>Agora, no controller que estamos enviando os e-mails, teremos que fazer algumas mudanças no controller.</p><pre>await Mail.sendMail({</pre><pre>  to: &#39;Exemplo de Destinatário &lt;exemplo-destinarario@gmail.com&gt;&#39;,<br>  subject: &#39;Envio de e-mail com NodeJS e Nodemailer&#39;,<br>  template: &#39;cancellation&#39;,<br>  context: {<br>    provider: &#39;Caique&#39;,<br>    user: &#39;Zezinho&#39;,<br>    date: format(<br>      parseISO(&quot;2020-05-20&quot;),<br>      &quot;&#39;dia&#39; dd &#39;de&#39; MMMM&#39;, às&#39; H:mm&quot;,<br>      {<br>      locale: pt,<br>      }<br>      ),<br>    },<br>})</pre><p>Nesta nova versão retiramos a propriedade text e passamos:</p><ul><li>template → Qual o template que será usado? No casso o cancellation (do arquivo cancellation.hbs)</li><li>context →Quais as informações vão no corpo do e-mail? (No {{{ body }}}). Aqui temos as informações que usei pro texto, e a data formatada.</li></ul><p>Pronto. Agora ao acessar a rota desse controller, o envio será feito. Vou provar :)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HZivkNjhdYsdnyXxRRpxQg.png" /></figure><p>Mas mandar um e-mail desse jeito faz a requisição ficar muito lenta, pois vai ser preciso esperar o término do envio para responder a requisição!</p><p>Então na última parte vamos brincar com o uso de filas :).</p><pre>})</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e6d959e787f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[E-mail + Background jobs no NodeJS]]></title>
            <link>https://medium.com/@cribeirorodrigues/e-mail-background-jobs-no-nodejs-248c5090cc51?source=rss-be3a333b065c------2</link>
            <guid isPermaLink="false">https://medium.com/p/248c5090cc51</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[nodemailer]]></category>
            <category><![CDATA[expressjs]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Caique Ribeiro Rodrigues]]></dc:creator>
            <pubDate>Tue, 31 Mar 2020 23:50:09 GMT</pubDate>
            <atom:updated>2020-06-24T14:45:20.730Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*HESUIsRwrt55ew5W_2XxEw.png" /></figure><p>Parte 1: Configurando o Nodemailer</p><p>E aí moçada, tudo certo? Nesse e nos demais tutoriais irei procurar mostrar algumas ideias interessantes para serem usadas com a stack Javascript (NodeJS, React e React Native). Primeiramente, irei abordar um assunto que, pelo menos para mim, foi bem demorado e custoso de descobrir como fazer corretamente: envio de e-mails.</p><p>Enquanto estudava Java principalmente, vi a configuração de bibliotecas de e-mail e background jobs como uma muito demorada. Com o Node, porém, a maioria das necessidades a serem supridas é bem mais simples. Então vamos começar. Lembrando que nesses primeiros tutoriais sempre estarei usando o express como dependência. Neste caso também estou usando também o <strong>Nodemon</strong> para não precisar ficar reiniciando o servidor e também o <strong>Sucrase</strong> para poder usar o import/exportao invés de module.exportse require. Hora do show.</p><h3>Configurando o Nodemailer</h3><p>O primeiro passo é configurar as dependências para o envio de e-mail. Para isso iremos utilizar o nodemailer, que é o gerenciador de envio de e-mails que sempre uso. Já instale as dependências secundárias nodemailer-handlebars nodemailer-express-handlebarspara podermos somente configurá- las depois, no segundo post. Após finalizar a instalação, crie um arquivo de configuração na pasta adequada do seu projeto. Aqui irei utilizar o nome mail.js e ficara na pasta src/configs.</p><pre>yarn add nodemailer nodemailer-handlebars nodemailer-express-handlebars</pre><p>No arquivo, iremos exportar um objeto com as configurações do e-mail, como host, porta, se é usado ou não SSL, o usuário do serviço de e-mail, campos que irão se repetir em todos os emails, etc. Como exemplo, coloquei o campo de remetente como<em> ‘Dono da sistema &lt;noreplay@system.com&gt;’ </em>e ele irá se repetir em todo e-mail enviado.O arquivo ficou assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AFyWrv8hvVbetxxpuROWrQ.png" /></figure><p>Para continuar, é preciso usar algum serviço de e-mail. Pode ser o próprio Gmail, Amazon SES, Mailchimp, etc. Apenas como base de teste iremos usar o Mailtrap (mailtrap.io). Não irei entrar em detalhes da configuração do Mailtrap, mas após configurá-lo, guarde as informações de host, port, user e pass. Não importa quem seja o destinatário, no Mailtrap todos os seus e-mail são enviados para você mesmo e ficam na sua caixa.</p><p>Para manter a organização das nossas informações de ambiente, vamos criar um arquivo .env na raiz do nosso projeto. Os arquivos .env são arquivos usados para armazenar as variáveis de ambiente do projeto em um único lugar e <strong>NÃO É ACONSELHÁVEL ENVIÁ-LOS AO GITHUB</strong>. Envie somente um .env-example com o valor das variáveis em branco. Para que possamos exportar o .env devemos instalar a dependência dotenv.</p><pre>yarn add dotenv</pre><p>Depois, dê um <strong>import dotenv/config</strong> no seu arquivo principal de servidor ou em uma classe intermediária que faça essas configurações de rotas, middlewares e erros.</p><p>No arquivo .env insira variáveis de acordo com seus dados do Mailtrap:</p><pre># Email</pre><pre>MAIL_HOST=smtp.mailtrap.io<br>MAIL_PORT=2525<br>MAIL_USER=seuusuario<br>MAIL_PASS=suasenha</pre><p>Com isso, será possível atualizar o arquivo mail.js para que fique assim:</p><pre>export default {</pre><pre> host: process.env.MAIL_HOST,<br> port: process.env.MAIL_PORT,<br> secure: false,<br> auth: {<br>  user: process.env.MAIL_USER,<br>  pass: process.env.MAIL_PASS,<br> },<br> default: {<br>  from: ‘Dono do sistema &lt;noreplay@system.com&gt;’<br> }</pre><pre>}</pre><p>Até agora só fizemos configurações. Para o envio de e-mail, precisamos criar a classe que vai fazer o trabalho sujo. Na pasta src, crie uma outra pasta com o nome lib e nela um arquivo Mail.js (Você pode criar nomes e hierarquias diferentes de pastas depois, claro. Mas só depois que aprender!).</p><p>Nesse arquivo, iremos importar o nodemailer e as configurações que acabamos de fazer.</p><pre>import nodemailer from ‘nodemailer’;<br>import mailConfig from ‘../config/mail’;</pre><pre>class Mail {<br> constructor() {<br>   const { host, port, secure, auth } = mailConfig;<br>   <em>this</em>.transporter = nodemailer.createTransport({<br>   host,<br>   port,<br>   secure,<br>   auth: auth.user ? auth : null,<br>  });<br> }</pre><pre> sendMail(<em>message</em>) {<br>   return <em>this</em>.transporter.sendMail({<br>   …mailConfig.default,<br>   …message,<br>  });<br> }<br>}</pre><pre>export default <strong>new</strong> <em>Mail</em>();</pre><p>Nesta classe mail estamos fazendo algumas coisas.</p><ol><li>Importando o nodemailer e logo depois nossas configurações, com o nome de maiConfig. Pode ser qualquer nome.</li><li>No construtor estamos configurando o nodemailer, ou seja: Assim que uma instância de Mail.js for importada em algum outro arquivo, esta configuração já vai ser feita (isso porque já extamos exportando um new Mail(), ou seja, a classe já instanciada. Nesta configuração estamos pegando, com a desestruturação, alguns dados do mailConfige usando-as para criar uma conexão com nosso serviço Mailtrap. Para isso usamos nodemailer.createTransport() e colocamos seus resultado na variável transporter.</li><li>Estamos criando o método que realmente envia o e-mail. No sendMail(), recebemos os dados externos como uma variável message, pegamos os dados default das nossas configurações (lembra do <strong>Dono do Sistema &lt;noreply@system.com</strong>&gt;?) e damos um transporter.sendMail().</li></ol><p>Com isso, nosso envio de e-mail está grosseiramente configurado. Precisamos, claro, chamá-lo de algum lugar. Este lugar não importa, então irei chamar de um controller simples que responde à uma requisição GET no localhost/mail.</p><p>Importe a classe Mail no seu controller e use await Mail.sendMail()(O await precisa ser usado pois o Nodemailer é uma classe <strong>assíncrona</strong>!). No print é possível perceber que passei um objeto com as informações <strong>to</strong>, <strong>subject</strong> e<strong> text</strong>. Estes são dados que chegaram como a variável messagedentro do .sendMail()!</p><pre>import Mail from ‘../../lib/Mail’;</pre><pre>class IndexController {</pre><pre>  async index(<em>req</em>, <em>res</em>) {</pre><pre>   await Mail.sendMail({<br>     to: ‘Exemplo de Destinatário &lt;exemplo-destinarario@gmail.com&gt;’,<br>     subject: ‘Envio de e-mail com NodeJS e Nodemailer’,<br>     text: ‘Você acabou de aprender como enviar e-mails com o NodeJS!’<br>   })</pre><pre>  }</pre><pre>}</pre><pre>export default <strong>new</strong> <em>IndexController</em>();</pre><p>Rode o seu servidor e acesse a rota que chama o controller onde o e-mail está sendo enviado. Se tudo estiver certo, você receberá o e-mail na sua caixa do Mailtrap.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/957/1*aFM6ysq3KSuLAm5VO6LSfA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=248c5090cc51" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>