<?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 Otávio Paulino Pace on Medium]]></title>
        <description><![CDATA[Stories by Otávio Paulino Pace on Medium]]></description>
        <link>https://medium.com/@otaviopp8?source=rss-b13ec03567cf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*5Vc3_v4QvbS0153nurl-ng.jpeg</url>
            <title>Stories by Otávio Paulino Pace on Medium</title>
            <link>https://medium.com/@otaviopp8?source=rss-b13ec03567cf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 13:58:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@otaviopp8/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[O que é Teoria das Categorias?]]></title>
            <link>https://medium.com/@otaviopp8/o-que-%C3%A9-teoria-das-categorias-5e7ed0d64a94?source=rss-b13ec03567cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/5e7ed0d64a94</guid>
            <category><![CDATA[category-theory]]></category>
            <dc:creator><![CDATA[Otávio Paulino Pace]]></dc:creator>
            <pubDate>Thu, 26 Sep 2019 00:39:20 GMT</pubDate>
            <atom:updated>2019-09-26T00:39:20.723Z</atom:updated>
            <content:encoded><![CDATA[<p>Há algumas semanas atrás eu fiz um curso de <em>Teoria das Categorias</em> na UFABC, e apesar disso não me fazer nenhum especialista no assunto, decidi que criaria esse artigo para tentar passar o que eu aprendi. Principalmente por sentir que existe muito misticismo no assunto para quem não conhece.</p><p>Mas afinal, o que é <em>Teoria das Categorias</em>?</p><p>É um tema originado na matemática que tem como base <strong>objetos</strong> e <strong>morfismos</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FJDJjMTV8e2sesOU" /><figcaption><em>Não se assuste, a imagem é mais simples do que imagina!</em></figcaption></figure><p>Olhando para a ela, os <strong>objetos</strong> são X, Y e Z. E os <strong>morfismos</strong>, são aquilo que <strong>transforma um objeto em outro</strong>, ou seja, f e g (as setas). Como temos algo que transforma de X para Y e outro de Y para Z, podemos ter um morfismo que faz as duas operações! Em matemática isso é expressado com ∘, no nosso cenário é g ∘ f.</p><p>E sim o operador ∘ é da direita para esquerda, ou seja, o f seria aplicado, para então o g ser aplicado em seu resultado.</p><p>Teoricamente é possível aplicar a <em>Teoria das Categorias</em> para quase qualquer coisa. Por algum motivo, alguém um dia decidiu relacionar isso com programação. É possível fazer a relação entre os dois assuntos de várias formas, a mais comum é mapear objetos para <strong>tipos</strong> e morfismos para <strong>funções</strong>.</p><p>Como os objetos, no nosso caso <strong>tipos</strong> em programação, são fundamentais para falar da teoria das categorias, irei mostrar os exemplos em uma linguagem estaticamente tipada que considero acessível, TypeScript.</p><p>Um exemplo em código da imagem anterior seria:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b41f8c62e05ac3aca9c38019d391c6df/href">https://medium.com/media/b41f8c62e05ac3aca9c38019d391c6df/href</a></iframe><p>Ta, então uma <em>categoria</em> é um conjunto de objetos e morfismos?</p><p>Quase isso.</p><p>Para ser uma <em>categoria</em>, além de mapear os objetos e morfismos, é necessário também cumprir algumas regras na composição ( ∘), são elas:</p><ul><li>Associatividade;</li><li>Identidade.</li></ul><p>A associatividade tem a ver com poder agrupar as operações em qualquer ordem, garantindo que terão o mesmo resultado.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a3cdcbb400c0bfa017b47a2b548eca69/href">https://medium.com/media/a3cdcbb400c0bfa017b47a2b548eca69/href</a></iframe><p>Já a identidade é sobre ter um morfismo que leva de um <strong>objeto</strong> a ele mesmo, de forma que se for composto a outro morfismo que começa ou termina nesse objeto, acaba no mesmo resultado.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e2fc894d20edf9972611052007d57591/href">https://medium.com/media/e2fc894d20edf9972611052007d57591/href</a></iframe><p>Agora que temos uma definição (ou quase isso), vou mostrar algumas das <em>categorias</em> mais conhecidas e faladas, e tentar desmistificar elas.</p><h3>Monoids</h3><p>A primeira <em>categoria</em> que as pessoas costumam aprender é <strong>Monoid</strong>. A primeira coisa que é possível induzir pelo nome é a palavra <strong>mono</strong>, que vem de <strong>um</strong>.</p><p>Esse <em>um</em> se trata dela conter apenas <strong>um objeto</strong>.</p><p>Para ser um Monoid é preciso ter as seguintes duas propriedades:</p><ul><li>Um operador binário. Ex: um morfismo que recebe dois parâmetros e retorna um;</li><li>Um elemento neutro.</li></ul><p>Mapeando esses conceitos para programação, podemos considerar que <em>categorias</em> podem ser encararadas como <strong>interfaces</strong>. Se você não conhece o conceito de interfaces, eu aconselho entender isso antes, caso não tenha mexido ainda em uma linguagem que tenha essa funcionalidade.</p><p>Segue abaixo a definição escrita acima, na forma de código:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1abc85e931eac5fd62633e4bc09e8416/href">https://medium.com/media/1abc85e931eac5fd62633e4bc09e8416/href</a></iframe><p>Você pode não saber, mas já conhece exemplos de Monoid. Um deles é a <strong>soma de números inteiros</strong>. Pare para pensar, o que caracteriza uma soma?</p><ul><li>Dois lados, os quais serão unidos para gerar um número;</li><li>Um número base que pode ser somado “n” vezes a ele mesmo e/ou a outros números, que sempre gera o mesmo resultado (5 + 0 + 0 = 5).</li></ul><p>Consegue ver como essas duas características podem ser interpretadas como uma Monoid?</p><p>Exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/15ca507b59d9eef1357a3442e41eda7b/href">https://medium.com/media/15ca507b59d9eef1357a3442e41eda7b/href</a></iframe><blockquote><em>O exemplo acima não implementa exatamente a interface no </em><em>TypeScript, fiz dessa forma pois achei mais simples. Criei outro exemplo que cria um novo tipo </em><em>Number para implementar a interface Monoid caso queira ver: </em><a href="https://gist.github.com/otaviopace/3b76295a8389da666c2fc51653f5d0fd"><em>Link para o código</em></a><em>.</em></blockquote><p>Uma outra operação que podemos encaixar no conceito de Monoid é a <strong>multiplicação de números inteiros</strong>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3096a1eba9950e402a221bbc5b549d9a/href">https://medium.com/media/3096a1eba9950e402a221bbc5b549d9a/href</a></iframe><p>A diferença é que para a multiplicação, o número neutro é 1, visto que 5 * 1 * 1 é igual a 5.</p><p>Existem dois outros exemplos de Monoid que você conhece e talvez não tenha percebido!</p><p>São eles <strong>Strings</strong> e <strong>Arrays</strong>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f34b20cfa7476fe881aeee4daa2e9f8c/href">https://medium.com/media/f34b20cfa7476fe881aeee4daa2e9f8c/href</a></iframe><blockquote><em>Uma nota que gostaria de dizer é que a função </em><em>mempty teoricamente deveria ser implementada como um método estático, pois tem mais a ver com o tipo do que com uma instância do tipo. Isso não foi feito pois </em>interfaces<em> em </em><em>TypeScript não podem ter métodos estáticos, e eu achei que ficava mais claro agrupar tudo em uma </em>interface<em> só.</em></blockquote><h3>Functors</h3><p>Um <strong>Functor</strong> é uma categoria que mapeia os objetos e morfismos de uma categoria, para outra.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/436/0*BwdpRPm7CYjCSeAJ" /></figure><p>Se formos pensar na categoria dos tipos, ou seja, mapear objetos para tipos e morfismos para funções, teriamos na verdade <strong>Endofunctors</strong>, que mapeiam da categoria dos tipos para ela mesma.</p><p>Ou seja, uma categoria dos tipos teria todos os tipos de uma linguagem, exemplo: Number, String, Array, etc, e um Functor transformaria um valor de um tipo para outro, ou para um valor do mesmo tipo, pois todos estão dentro da mesma categoria, a dos tipos!</p><p>Tenha calma, todas essas palavras ficarão mais claras com os exemplos. E você provavelmente já conhece um exemplo de Functor.</p><p>A <em>interface</em> de um Functor seria algo como isso:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9ccd84ce209bf50fcac4c5da5165799c/href">https://medium.com/media/9ccd84ce209bf50fcac4c5da5165799c/href</a></iframe><p>Ou seja, ele define uma função para um Functor do tipo A o qual recebe uma função f que mapeia um valor do tipo A, para um valor do tipo B, e de retorno o fmap entrega um Functor do tipo B.</p><p>Que confusão de tipos!!</p><p>Vamos pensar em um cenário simples, imagine o tipo abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f1ff9a370121c5e014c50ce1ba1fcc1c/href">https://medium.com/media/f1ff9a370121c5e014c50ce1ba1fcc1c/href</a></iframe><p>O que temos aqui é uma classe simples que guarda um valor de qualquer tipo na sua construção.</p><p>Vamos supor que temos um Container que guarda um inteiro, e queremos o converter pra string, mantendo o valor no Container. Uma forma de fazer isso é implementando Functor para nosso tipo!</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/469fb1692a53dd343d24c5efb3c65329/href">https://medium.com/media/469fb1692a53dd343d24c5efb3c65329/href</a></iframe><blockquote><em>Inclusive, uma melhoria no código acima poderia ser só passar a função </em><em>String como parâmetro (</em><em>(a) =&gt; String(a) vs </em><em>String), mas fiz da forma acima para ficar mais explícito o que acontece.</em></blockquote><p>Um container que você já conhece hoje que tem a função fmap é o Array do JavaScript, só não tem o prefixo f no nome!</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/03dbaa43a7d14a73b6d9f8dada73c01e/href">https://medium.com/media/03dbaa43a7d14a73b6d9f8dada73c01e/href</a></iframe><p>No caso o map aplica a função passada por parâmetro em todos os seus itens, gerando uma nova lista de mesmo tamanho, com os novos valores.</p><p>Como pode ver o Functor mapeia algo de um tipo a outro o mantendo sua estrutura de dados, independente de criar uma nova ou não.</p><h3>Monads</h3><p>Aquela que todos que a entendem tem pós graduação em ciências da computação!</p><p>A <strong>Monad</strong> tem conceitos similares as duas outras categorias acima. Vamos defini-la:</p><ul><li>Possui uma operação similar ao fmap, mas ao invés de mapear algo do tipo A para o tipo B, ela mapeia o tipo A, para uma Monad do tipo B;</li><li>Uma operação, que constrói uma Monad a partir de um valor.</li></ul><p>Em código seria algo como:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/954f6604d7cc1e47c482604351cbce04/href">https://medium.com/media/954f6604d7cc1e47c482604351cbce04/href</a></iframe><blockquote><em>Na verdade, existe mais de uma implementação de Monad, mas utilizei a acima pois é a mais utilizada hoje em dia.</em></blockquote><p>Implementando usando nosso tipo Container:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/70682c6624321bfe52ab8587084d8c45/href">https://medium.com/media/70682c6624321bfe52ab8587084d8c45/href</a></iframe><blockquote><em>Assim como comentei que o método </em><em>mempty de Monoid mapearia melhor se fosse um método estático, o </em><em>return de Monad também. Digo isso pois não precisam do objeto inicial, apenas dos argumentos.</em></blockquote><p>Assim como o fmap, também temos o bind no JavaScript, e seu nome é flatMap!</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/235aece10cadc19a24dbb947653ae414/href">https://medium.com/media/235aece10cadc19a24dbb947653ae414/href</a></iframe><blockquote><em>O </em><em>flatMap não chega a ser exatamente igual ao </em><em>bind, mas possui suas similaridades.</em></blockquote><p>Já o return, com um nome infeliz nas linguagens C-like, lembra mais a ideia de um construtor, que pega um valor qualquer e transforma no Container.</p><h3>Conclusão</h3><p>Teoria das Categorias é um assunto extenso, e possui uma profundiade e complexidade muito maior do que o que mostrei aqui. Caso tenha interesse em entender mais do assunto, recomendo o livro Category Theory for Programmers.</p><p>Espero ter clareado um pouco mais o que é Teoria das Categorias e o que é cada uma das 3 categorias que apresentei, e se possível ter despertado mais curiosidade no assunto em você.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e7ed0d64a94" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Graceful shutdown com Node.js e Docker]]></title>
            <link>https://medium.com/@otaviopp8/graceful-shutdown-com-node-js-e-docker-820b36fd04f3?source=rss-b13ec03567cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/820b36fd04f3</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Otávio Paulino Pace]]></dc:creator>
            <pubDate>Mon, 25 Jun 2018 14:08:35 GMT</pubDate>
            <atom:updated>2018-06-25T14:08:35.390Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*MNEroB8WMS9K34IB-U8kNA.jpeg" /><figcaption>Eu caindo graciosamente \o/</figcaption></figure><h3>O que é graceful shutdown?</h3><p>Quando uma aplicação é terminada ou interrompida, ela pode estar no meio de uma operação, uma requisição a outro serviço por exemplo. Caso isso ocorra, inconsistências podem acontecer. Portanto, o ideal é que quando a aplicação seja terminada ela saiba lidar com isso e finalizar tudo que estiver no meio, seja terminar uma requisição já iniciada ou liberar recursos. Isso é graceful shutdown.</p><p>Para realizar isso, é necessário utilizar os sinais de comunicação entre processos do sistema operacional.</p><h3>O que são sinais IPC (I<strong>nter-Process Communication)</strong>?</h3><p>Sabe quando usa Ctrl + C ou kill com umpidpara finalizar um programa no terminal? Basicamente isso envia um sinal para ele ser interrompido/terminado, ou seja, você já envia sinais para processos!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/1*-xClxdgcczhWR4fSX93KlQ.png" /><figcaption>Tabela com alguns sinais e suas descrições e ações padrão</figcaption></figure><p>O funcionamento deles é o seguinte: caso seja enviado um sinal a um processo, o sistema operacional vai chamar a rotina desse processo para o sinal, caso ela não exista, ele utiliza a padrão. Exemplo: se eu utilizo Ctrl + C em um programa, é enviado um sinal de SIGINT para ele, caso ele tenha declarado uma função para lidar com esse evento, ela será chamada, se não, será utilizada a padrão que é interromper o processo.</p><h3>Como escutar um sinal no Node.js?</h3><p>Nada melhor para aprender algo do que ter um exemplo prático! No código abaixo são definidas 3 funções que irão ser chamadas quando o processo receber 3 sinais distintos. SIGTERM é o sinal para terminação, código 15. SIGINT é o sinal para interrupção, ele por exemplo é o utilizado no Ctrl + C e possui código 2. Já o SIGHUP é o de reload de arquivos de configuração ou de finalização da sessão do terminal, seu código é 1.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e8121a848900e08f1dbf6def2807ffb3/href">https://medium.com/media/e8121a848900e08f1dbf6def2807ffb3/href</a></iframe><p>Esse programa irá se comportar da seguinte forma: nas três primeiras linhas estarão sendo sobreescritas as funcionalidades caso ocorra algum dos três sinais, depois de 10 em 10 segundos será escrito no terminal doing useless work!, isso será utilizado para representar algum trabalho que o script estaria fazendo.</p><p>Executando o script acima com node signal.js pode se observar o seguinte resultado no terminal após pressionar Ctrl + C algumas vezes no teclado.</p><pre>^Cint<br>^Cint<br>^Cint<br>doing useless work!</pre><p>Basicamente nosso programa está recebendo o sinal para ser interrompido através do Ctrl + C. Como definimos uma outra função para ser chamada ao invés da padrão (finalização do processo), ela está sendo chamada no lugar, e assim colocando no console int para cada sinal SIGINT.</p><p>Caso não tenha percebido, acabamos de criar um processo que não pode ser finalizado, seja por SIGINT (Ctrl + C), SIGTERM ou fechando o terminal (SIGHUP). Como podemos pará-lo de vez?</p><p>Se quiser finalizar o processo, terá de usar o programa kill. Por padrão ele envia um sinal que não pode ser escutado (SIGKILL) e que finaliza o processo independente do que estiver acontecendo. Tudo que esse programa precisa é do pid do processo, para conseguir esse valor é só utilizar comando:</p><pre>&gt; ps ax | grep &quot;node signal.js&quot;</pre><pre>4562 pts/2    Sl+    0:00 node signal.js</pre><p>Então executar kill -9 4562. O 9 é o número do sinal de SIGKILL.</p><p>Caso tente ser espertinho e tentar escutar o sinal SIGKILL, irá receber um erro, pois ele não pode ser escutado, assim como alguns outros sinais específicos como SIGSTOP.</p><h3>Como realizar graceful shutdown de um servidor HTTP?</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7abd49cba19be363a7f8fcd348d6674d/href">https://medium.com/media/7abd49cba19be363a7f8fcd348d6674d/href</a></iframe><p>O exemplo acima contempla um servidor HTTP bem simples com somente uma rota. Caso alguém realize uma requisição nessa rota, irá demorar 10 segundos para ser respondido.</p><p>Se ocorrer uma requisição na rota /wait e o servidor for terminado no meio do processo, o cliente irá ficar sem resposta.</p><pre>&gt; curl localhost:8000/wait<br>curl: (52) Empty reply from server</pre><p>Para resolver isso iremos utilizar o que vimos no exemplo dos sinais:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7d5dd119e37297cd2cfb229c0a31c79a/href">https://medium.com/media/7d5dd119e37297cd2cfb229c0a31c79a/href</a></iframe><p>Observe que o código acima só tem uma adição, a função setupGracefulShutdown, que irá configurar o que o programa deve fazer quando o servidor for terminado.</p><p>Caso tente simular o comportamento anterior nesse novo servidor, o cliente irá receber a resposta conforme pediu e esses serão os logs do programa:</p><pre>&gt; node express<br>Started wait!<br>^CSIGINT happened!<br>Done!<br>server closed!</pre><p>Mas o que de fato está acontecendo e o que é esse server.close(callback)?</p><p>Considerando o cenário em que o cliente envia uma requisição e o servidor recebe um sinal de SIGINT, basicamente ele irá chamar o callback que inicia a função server.close. Essa função não é do express, e sim do módulo nativo http do Node.js. Link para documentação: <a href="https://nodejs.org/api/http.html#http_server_close_callback">https://nodejs.org/api/http.html#http_server_close_callback</a>.</p><p>A função listen do express, retorna uma instância da classe Server do módulo http, por isso podemos chamar a função close no retorno dela.</p><p>Essa função basicamente faz com que o servidor pare de receber requisições e termine todas as que estão em andamento, assim que isso ocorrer, irá chamar nosso callback passado para ele. Quando isso ocorre, o cliente recebe sua resposta e enfim terminamos o servidor com o devido código de finalização.</p><p>Quanto ao número 128, isso é um padrão pois o código de saída é restrito a um inteiro de 8 bits (0–255).</p><p>Lembrando que é de nossa responsabilidade chamar process.exit, já que sobreescrevemos a funcionalidade padrão de terminar o processo.</p><h3>Agora utilizando Docker</h3><p>Bom para isso, iremos criar um package.json e um Dockerfile.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3b870d788a481c730d521f303c01165d/href">https://medium.com/media/3b870d788a481c730d521f303c01165d/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/53e91f798a782ea633e894b89810b4b9/href">https://medium.com/media/53e91f798a782ea633e894b89810b4b9/href</a></iframe><p>Para construir a imagem iremos utilizar o seguinte comando:</p><pre>docker build . -t graceful-server</pre><p>E para iniciar o contêiner:</p><pre>docker run -p 8000:8000 --name=graceful-server graceful-server</pre><p>Excelente! Vamos agora testar para ver se comportamento continua como o esperado:</p><pre>&gt; curl localhost:8000/wait<br>curl: (52) Empty reply from server</pre><p>Hmm, que estranho. Por que nosso servidou deixou de escutar os sinais?</p><p>Vamos entrar no contêiner e tentar entender o que acontece:</p><pre>&gt; docker exec -it graceful-server /bin/sh<br>/ # ps -o ppid,pid,comm<br>PPID  PID   COMMAND<br>    0     1 npm<br>    1    16 sh<br>   16    17 node<br>    0    23 sh<br>   23    39 ps</pre><p>Aqui PPID significa parent pid, PID significa process id e COMMAND é o comando atrelado ao processo.</p><p>Nosso servidor está rodando normalmente, porém, quem iniciou ele foi umshell script, e quem iniciou este foi o npm. Basicamente nosso sinal não está sendo propagado a frente. Existem algumas issues em repositórios relacionados ao Node e NPM, porém este é comportamento que temos hoje.</p><p>Uma forma simples de resolver isso é trocar o CMD [“npm&quot;, “start&quot;] no Dockerfile por CMD [&quot;node”, “server.js&quot;].</p><p>Assim nossos logs no servidor ficam da serguinte forma:</p><pre>&gt; docker run -p 8000:8000 --name=graceful-server graceful-server<br>Started wait!<br>^CSIGINT happened!<br>Done!<br>server closed!</pre><p>E no cliente:</p><pre>&gt; curl localhost:8000/wait<br>Done!⏎</pre><p>Uhulll!! Agora sabe o que é graceful shutdown e como implementar utilizando Node.js e Docker!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*_2n8UeftIGYrc500Djim8g.jpeg" /><figcaption>Eu após a caída graciosa :)</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=820b36fd04f3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>