<?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 Leonardo Carmo on Medium]]></title>
        <description><![CDATA[Stories by Leonardo Carmo on Medium]]></description>
        <link>https://medium.com/@leonardocarmo?source=rss-e55130c73afb------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*1GxockoIV4uWFe9GskIWvw.png</url>
            <title>Stories by Leonardo Carmo on Medium</title>
            <link>https://medium.com/@leonardocarmo?source=rss-e55130c73afb------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 04:32:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@leonardocarmo/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[Graceful Shutdown com PHP — Evitando data corruption]]></title>
            <link>https://leonardocarmo.medium.com/graceful-shutdown-com-php-evitando-data-corruption-b0a1156a6ed6?source=rss-e55130c73afb------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0a1156a6ed6</guid>
            <category><![CDATA[graceful-shutdown]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[php-fpm]]></category>
            <category><![CDATA[datacorruption]]></category>
            <category><![CDATA[pcnt]]></category>
            <dc:creator><![CDATA[Leonardo Carmo]]></dc:creator>
            <pubDate>Mon, 03 May 2021 12:22:06 GMT</pubDate>
            <atom:updated>2021-05-03T16:24:57.068Z</atom:updated>
            <content:encoded><![CDATA[<h3>Graceful Shutdown com PHP — Evitando data corruption</h3><p>Quando trabalhamos com processos críticos, seja via <em>script</em> em <em>background</em> ou via o fluxo transacional de APIs, temos algo muito importante para considerar: <strong>a possibilidade de interromper um processamento antes que ele termine, causando uma corrupção de dados <em>(data corruption)</em></strong>.</p><h4>Certo, mas o que isso significa e quais os impactos?</h4><p>Vamos pensar em um fluxo que conhecemos muito bem hoje: as transações em bancos de dados relacionais. Usamos isso quando precisamos garantir que dados sejam inseridos/alterados/deletados em conjunto, garantindo assim a consistência dos mesmos. Ou seja, se em algum momento da transação algo der errado, realizamos o <em>rollback</em>, caso contrario, o <em>commit</em> da transação.</p><p>Com isso em mente, vamos mudar o contexto para um <em>script</em> em <em>background</em> que precisa realizar uma determinada tarefa com vários <em>steps</em>, normalmente um while(true) que assina um tópico/fila e fica processando sem tempo definido. Mais conhecido como <em>&quot;moedor de carne&quot;</em> rs…</p><p>Agora vamos pensar que cada loop demore cerca de 1s para realizar a tarefa e este <em>script</em> está em um <em>container</em> que receberá uma nova versão de código, assim, o mesmo precisará ser destruído e um novo assumirá.</p><p>No momento do <em>deploy</em>, o <em>container</em> será forçado a desligar e poderá estar no meio de um processamento, que leva cerca de 1s, lembra?</p><blockquote>O que pode acontecer com o que estava sendo feito no loop? Tente pensar antes de continuar!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*jrrPFOVimVRjlkNtmaqI5g.gif" /></figure><p>Resposta: não sabemos! Ele pode ter forçado o desligamento em qualquer <em>step</em>. Pode ter sido no meio de uma transação de banco onde a mesma vai ficar presa até expirar, seja no envio de dados incompletos para outros serviços, geração de eventos &quot;fantasmas&quot;, e por aí vai…</p><p>Evitar essa corrupção de dados é uma tarefa bem simples, basta entender esse fluxo de desligamento e terminar de fazer o que estava sendo feito antes de realmente desligar o serviço. Lembrando que isso também vale para APIs, precisamos terminar uma requisição em andamento antes de desligar o serviço.</p><h4>Processo de shutdown no Kubernetes</h4><p>Basicamente podemos resumir em dois momentos, primeiro um aviso de desligamento, conhecido como SIGTERM, e o desligamento forçado, conhecido como SIGKILL, que será enviado caso o <em>container</em> não tenha terminado após o aviso.</p><blockquote>Caso queira entender um pouco mais sobre estes sinais, <a href="https://major.io/2010/03/18/sigterm-vs-sigkill/">veja este artigo</a> que explica bem a diferença entre cada um deles.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ivg_k3xmSpOXyE5K.jpg" /><figcaption>Podemos ver cada estágio do lifecycle do Pod nesta imagem, onde nosso foco está na última caixinha da direita, onde temos o pre stop hook, que emite o sinal de TERM e aguarda o desligamento do container. Veja o video completo deste diagrama <a href="https://www.youtube.com/watch?v=lnAwa8IFaLU">aqui</a>.</figcaption></figure><blockquote>Para entender cada detalhe deste processo, você pode acessar a <a href="https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination">documentação oficial</a>. Caso você não tenha sua arquitetura rodando com essa tecnologia não se preocupe, o processo é similar e existem vários artigos que você pode consultar, o importante é que você entenda o fluxo de shutdown e aplique conforme sua realidade.</blockquote><p>Sendo assim, o que devemos fazer é <em>&quot;escutar&quot;</em> esse aviso de desligamento, terminar o que estamos fazendo e desligar o <em>container</em> com a segurança de que nenhum processo estava em andamento, evitando a corrupção dos dados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*ykmKs1nL9kb03_zC.gif" /></figure><h4>Com tudo isso em mente, vamos focar na solução!</h4><p>Começando pelo <em>web server</em>, utilizando o php-fpm esta tarefa é simples. Temos um parâmetro para configurar quanto tempo os child processes possuem para finalizar o processo atual antes de desligarem:</p><pre>process_control_timeout = 10s</pre><p>Conforme a <a href="https://www.php.net/manual/en/install.fpm.configuration.php#process-control-timeout">documentação oficial</a>, o valor padrão deste parâmetro é zero, com isso, assim que os child processes recebem o sinal eles encerram, o que pode ser bastante danoso.</p><blockquote>É importante lembrar que no Kubernetes, depois do alerta, caso o processo não tenha sido encerrado, ele é forçado a encerrar, então o valor deste parâmetro precisa dar match com o tempo máximo de uma requisição processada com sucesso e o tempo de espera do Kubernetes até forçar o desligamento.</blockquote><h4>Scripts de processamento em background, via PHP CLI</h4><p>Agora vamos falar dos <em>scripts</em> que trabalham em while(true) e não possuem nada para avisar o loop de que um sinal de desligamento foi enviado.</p><p>Para resolver este problema, temos uma extensão para o PHP chamada de <a href="https://www.php.net/manual/en/intro.pcntl.php">pcntl</a> que consegue registrar <em>handlers</em> para sinais enviados ao processo, ou seja, conseguimos <em>&quot;escutar&quot;</em> quando o Kubernetes nos avisar que devemos encerrar.</p><blockquote>Importante: esta funcionalidade não deve ser habilitada em contextos de web server, exemplo do php-fpm, pois pode ocasionar em comportamentos inesperados. O seu uso correto é para scripts utilizando o PHP CLI.</blockquote><p>Para facilitar a implementação e utilização desta extensão, criei uma <em>lib</em> bem simples que faz toda essa mágica acontecer:</p><p><a href="https://github.com/leocarmo/graceful-shutdown-php">leocarmo/graceful-shutdown-php</a></p><p>Com ela, você consegue garantir que nenhum dado será corrompido caso o desligamento seja necessário e, caso seja necessário, registrar um <em>callback</em> para ser executado antes do desligamento.</p><p>Se código ficará parecido com este:</p><pre>use LeoCarmo\GracefulShutdown\GracefulShutdown;<br><br>$shutdown = new GracefulShutdown();<br><br>while (! $shutdown-&gt;signalReceived()) {<br><br>    echo &#39;Start long task...&#39; . PHP_EOL;<br>    sleep(sleep(5)); // --&gt; when a signal is sent, sleep returns the number of seconds left<br>    echo &#39;End long task...&#39; . PHP_EOL;<br><br>}<br><br>echo &#39;Graceful shutdown!&#39;;</pre><p>Por ora é isso, espero poder te ajudar a construir aplicações mais consistentes e evitar a corrupção de dados, tanto no fluxo de requisições, quanto via <em>scripts</em>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0a1156a6ed6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Guia: Alta performance com PHP — Suas aplicações backend no próximo nível]]></title>
            <link>https://leonardocarmo.medium.com/guia-alta-performance-com-php-suas-aplica%C3%A7%C3%B5es-backend-no-pr%C3%B3ximo-n%C3%ADvel-c0a3ca9aed10?source=rss-e55130c73afb------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0a3ca9aed10</guid>
            <category><![CDATA[php]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[swoole]]></category>
            <category><![CDATA[laravel]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Leonardo Carmo]]></dc:creator>
            <pubDate>Tue, 12 May 2020 22:51:55 GMT</pubDate>
            <atom:updated>2020-05-13T11:35:13.094Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-oOAJ0FLbqR8pm8b1GFllw.jpeg" /></figure><h3>Guia: Alta performance com PHP — Suas aplicações backend no próximo nível</h3><p>Muitas pessoas dizem que alta performance e PHP não existem na mesma frase. Se você <strong><em>ainda</em></strong> pensa assim, vou te provar o contrário.</p><p>O PHP é muito poderoso, só depende de nós utilizá-lo da melhor forma. Meu objetivo com esta publicação é ajudar nesta jornada.</p><p>Todo mundo já sabe que grandes empresas usam PHP, mas esse não é o argumento mais forte ao se falar sobre este assunto.</p><p>Argumentos fortes são: <strong>aplicações poderosas</strong>, <strong>resoluções de problemas de forma inteligente</strong> e <strong>implementações diferentes do comum</strong>. E vamos falar muito sobre isso aqui!</p><p>Não vou abordar apenas tópicos voltados ao código, a ideia é falar sobre o ambiente como um todo: <strong>arquitetura</strong>, <strong>implementações</strong> e, claro, <strong>código</strong>.</p><p>Um ponto importante é que vamos <strong>focar exclusivamente em aplicações backend</strong>, funcionando <strong><em>sem renderização de views</em></strong>. Pois, caso sua aplicação seja full stack, muitas outras otimizações ainda precisam ser feitas.</p><p>Começaremos do básico e vamos aprofundando em assuntos mais complexos aos poucos. Alguns tópicos irei apenas trazer ideias iniciais, e depois te direcionar para outras publicações onde você possa estudar e entender mais sobre eles.</p><p>Quero te guiar pelas melhores práticas para conseguir, de fato, elevar o nível das suas aplicações de forma fácil e objetiva. Então bora lá!</p><h4>Tópicos</h4><ol><li><a href="#93a4">Atualize TUDO, sempre!</a></li><li><a href="#cb48">Refatore sua infraestrutura</a></li><li><a href="#43a8">Boas práticas e padrões de projeto</a></li><li><a href="#3122">Frameworks</a></li><li><a href="#5b3e">Otimizando o PHP-FPM</a></li><li><a href="#9c93">O poder do OPcache</a></li><li><a href="#35a3">Utilize cache em memória</a></li><li><a href="#98d8">Conexões persistentes</a></li><li><a href="#a1f1">Funções nativas</a></li><li><a href="#e001">Preloading</a></li><li><a href="#e824">Generators</a></li><li><a href="#596a">Código assíncrono</a></li><li><a href="#d899">Non-blocking I/O com PHP</a></li></ol><h3>1. Atualize TUDO, sempre!</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/910/0*PRqeK_xunQ4yP__q" /></figure><p>É, parece bem óbvio. Mas quando foi a última vez que você atualizou as dependências do seu projeto? E a versão do PHP?</p><p>De acordo com a <a href="https://w3techs.com/technologies/details/pl-php">W3Techs</a>, o PHP é utilizado por 78.2% de todos os websites, considerando sua linguagem de backend.</p><blockquote><strong>WOOW THAT’S AWESOME!</strong></blockquote><p>Nem tanto… Essa é uma das razões de muita gente não gostar de PHP e falar coisas bem ruins (digamos que, nesse caso, não estão errados).</p><p>A versão 7 é utilizada por apenas 50.8% desses websites. Ou seja, a outra metade está utilizando uma versão terrível…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/722/1*ZSIxYccCAXqb2ED8hC-wNA.png" /></figure><p>E ainda fica pior, mesmo na versão 7, menos de 30% estão utilizando uma <a href="https://www.php.net/supported-versions.php">versão com suporte ativo</a>, analisando o dia que estou escrevendo. E apenas 3.6% estão na ultima versão estável disponível (7.4), o que é péssimo!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*CWKvvfAwkYAO-jipA2kpXA.png" /></figure><p>Mas o que isso tem a ver com performance? TUDO! Alem de ficar cada vez mais performático, muitas atualizações de segurança são lançadas, o que já seria suficiente para você atualizar seu PHP.</p><blockquote>Lembre-se: alem do PHP, é preciso atualizar suas <strong>dependências do composer e suas extensões</strong>!</blockquote><p>Para ver um pouco mais sobre testes de performance, <a href="https://kinsta.com/blog/php-benchmarks/">acesse este link</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ffv_ddLYQGYZcG0C.png" /></figure><blockquote>E o <a href="https://stitcher.io/blog/new-in-php-8">8.0 vem aí</a> com novidades e, claro, mais <a href="https://thephp.website/br/edicao/php-8-jit/">melhorias em performance</a>. Aqui falamos apenas do PHP, mas temos extensões e bibliotecas também, então: atualize TUDO, sempre!</blockquote><h3>2. Refatore sua infraestrutura</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/646/0*-NY9jCYRvhDXAF25" /></figure><p>Mais uma coisa óbvia? Talvez. Mas sabemos que muitos sistemas rodam tudo no mesmo servidor: banco de dados, aplicação, webserver, cache, sistema de arquivos…</p><p>Algumas pessoas justificam isso dizendo que é para redução de custos. De início tudo bem, mas se seu sistema começar a crescer, essa conta não vai ficar barata. Dividir processamento entre diversos processos vai degradar a performance como um todo, mesmo com muito recurso disponível.</p><p>Dividir os serviços que você utiliza, permite um gerenciamento por demanda dos recursos. Ou seja, caso seu banco precise de mais memória, apenas ele sofre um upgrade pontual, sem precisar ter uma máquina gigante com tudo dentro.</p><p>Essa refatoração com certeza vai melhorar a performance do seu sistema como um todo e, dependendo do nível de tráfego, também vai reduzir seus custos e complexidade de gerenciamento.</p><p>Alguns serviços e dicas que podem ajudar:</p><ul><li>Nginx no lugar do Apache (<a href="https://serverguy.com/comparison/apache-vs-nginx/">Por quê?</a> / <a href="https://www.nginx.com/blog/tuning-nginx/">Como?</a>)</li><li>Utilize <a href="https://dzone.com/articles/top-10-benefits-of-using-docker">Docker</a></li><li><a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html">Elastic container service</a></li><li><a href="https://aws.amazon.com/rds/?nc1=h_ls">Relational database service</a></li><li><a href="https://aws.amazon.com/s3/?nc1=h_ls">Cloud object storage</a></li></ul><blockquote>Você pode usar qualquer cloud provider, os links são para que você conheça mais sobre este tipo de serviço gerenciado.</blockquote><p>Esse é o básico para que você comece a refatorar sua infraestrutura. Existem muitos outros serviços interessantes que também podem ajudar, vamos falar sobre alguns deles em outros tópicos.</p><h3>3. Boas práticas e padrões de projeto</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*0jVoBgh1bVyvzsD2" /></figure><p>Não vou abordar cada padrão de projeto aqui, a ideia é ressaltar a <strong>importância de levar tudo isso muito a sério</strong>.</p><p>Por mais que sempre lemos essas palavras por aí, estamos realmente colocando isso em prática? Dentre todos os benefícios, <strong>performance com certeza está entre eles</strong>.</p><p>Podemos destacar a <a href="https://szymonkrajewski.pl/why-should-you-return-early/"><em>early return pattern</em></a>, que influencia diretamente a performance das aplicações quando trabalhamos com altas volumetrias. Quanto mais rápido conseguirmos responder uma requisição, mais rápido estaremos prontos para a próxima!</p><p>Utilizar padrões de projeto e boas práticas é trazer soluções inteligentes e performáticas para suas aplicações, então, sempre que fizer sentido, utilize!</p><blockquote><strong>Mas atenção, </strong><a href="https://en.wikipedia.org/wiki/KISS_principle"><strong>KISS</strong></a><strong>! Padrões não são soluções para tudo, saiba utilizar de forma inteligente e não como bala de prata.</strong></blockquote><p>Alguns materiais para se aprofundar no assunto:</p><ul><li><a href="https://sourcemaking.com/design_patterns">Design patterns</a></li><li><a href="https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design">SOLID</a></li><li><a href="https://www.php-fig.org/psr/">PHP Standards Recommendations</a></li><li><a href="https://en.wikipedia.org/wiki/Don%27t_repeat_yourself">Don’t repeat yourself</a></li><li><a href="https://github.com/leocarmo/circuit-breaker-php">Circuit Breaker Pattern</a> <em>— pretendo fazer um artigo exclusivo, em breve</em></li></ul><h3>4. Frameworks</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*lvVR7qNoTwbzY1gA.jpg" /></figure><p>Este sempre acaba sendo um assunto polêmico. Então, vamos tirar um pouco o foco apenas da perfomance e pensar em outros tópicos importantes para este assunto.</p><p>A escolha de um framework tem que levar outros aspectos em consideração, entre eles gostaria de destacar alguns:</p><ul><li>A equipe está confortável em trabalhar com ele?</li><li>A comunidade é ativa?</li><li>Ele é atualizado com qual frequência?</li><li>A documentação é bem estruturada?</li><li>Já pensou em usar um micro-framework?</li></ul><p>Estes são pontos que podem influenciar o futuro da sua aplicação, pois, se não for atualizado com frequência, sua performance pode ser degradada. Se a comunidade não estiver ativa o suficiente, o mesmo pode acontecer.</p><p>Então, ao escolher, leve em consideração outros aspectos importantes.</p><h3>5. Otimizando o PHP-FPM</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/0*vqky1FA97dybS_0P" /><figcaption><strong>fpm-workers</strong></figcaption></figure><p>Iniciando os tópicos um pouco mais avançados, vamos falar sobre o <a href="https://www.php.net/manual/en/install.fpm.php">php-fpm</a>. Aqui, vamos considerar que você já utiliza o Nginx com o php-fpm e que já <a href="https://www.inmotionhosting.com/support/website/php-fpm-the-future-of-php-handling/">saiba como ele funciona</a>, pelo menos de forma básica. Se não utiliza, a primeira recomendação é mudar para essa combinação extremamente poderosa.</p><p>As configurações que vamos abordar aqui, leva em consideração que seu sistema tem um grande volume de requisições.</p><p>Vamos focar aqui na configuração dos processos que serão abertos e gerenciados pelo fpm. Com isso, a melhor forma de gerenciar estes processos em alta volumetria é de forma estática. Assim, o fpm não vai precisar se preocupar em aumentar ou diminuir cada um deles.</p><p>Outro ponto importante é a quantidade de requisições que cada processo irá processar antes de ser renovado. Temos que pensar no equilíbrio, pois, enquanto um número muito alto pode causar um <a href="https://medium.com/@FreeDev/tenha-cuidado-com-o-memory-leak-b171622b4c6b">memory leak</a>, um número muito baixo pode fazer com que, a todo momento, o fpm tenha que lidar com o start de um novo processo. Então saiba quanto cada uma das suas requisições utiliza de memória para ajustar essa configuração, para isso <strong>faça </strong><a href="https://stackify.com/php-profiling-find-slow-code/"><strong>profilling</strong></a><strong>!</strong></p><p>Sendo assim, um exemplo de configuração seria:</p><pre>[api]<br>pm = static<br>pm.max_children = 16<br>pm.max_requests = 10000</pre><p>Com workers estáticos já teremos uma grande diferença. Claro, existem diversas outras configurações, então para saber um pouco mais, aqui tem <a href="https://geekflare.com/php-fpm-optimization/">um artigo</a> abordando mais sobre este assunto.</p><h3>6. O poder do OPcache</h3><p>Esta é uma extensão muito poderosa para o PHP, se você não utiliza, pare tudo e implemente o quanto antes! Para uma rápida introdução, o que diz a <a href="https://www.php.net/manual/en/book.opcache.php">documentação</a>:</p><blockquote>OPcache improves PHP performance by storing precompiled script bytecode in shared memory, thereby removing the need for PHP to load and parse scripts on each request.</blockquote><p>Com isso, já da pra sentir o poder que ele pode dar para suas aplicações. Todo o sistema será compilado apenas uma vez e estará disponível em memória para as próximas requisições. Show!</p><p>Um benchmark para mostrar o poder do OPcache:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/0*TYOwq00Io_Y7ujLo.png" /><figcaption><a href="https://ez.no/Blog/PHP-7.4-OPCache-Preloading-benchmark-results-note-on-database-extension-crashes">Fonte</a></figcaption></figure><p>Começar a utilizar é muito fácil, basta instalar, configurar e pronto! Porém, como aponta a documentação, todos os scripts vão para memória. Isso significa que, caso não utilize container, ao atualizar seu projeto, é preciso dar um reload no seu processo do fpm para que ele limpe os scripts antigos e recompile os novos.</p><p>Vou deixar aqui uma configuração bem interessante para iniciar:</p><pre>[opcache]<br>opcache.enable=1<br>opcache.memory_consumption=128<br>opcache.max_accelerated_files=4000<br>opcache.validate_timestamps=0<br>opcache.interned_strings_buffer=12<br>opcache.use_cwd=0</pre><p>Existem <a href="https://www.php.net/manual/en/opcache.configuration.php">diversas configurações disponíveis</a>, basta dar uma olhada na documentação e configurar conforme fizer sentido para sua aplicação. Para saber mais sobre o OPcache, existem muitos materiais bacanas disponíveis, <a href="https://www.cloudways.com/blog/integrate-php-opcache/">aqui tem um</a>.</p><h3>7. Utilize cache em memória</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*JUypqfdRBuZqnkwT.jpg" /></figure><p>&quot;Cachear&quot; sua aplicação de forma inteligente pode ser uma das coisas mais importantes para se obter um ganho expressivo em performance e redução de custos.</p><p>Sabe quando você precisa utilizar um mesmo código em dois lugares diferentes e, para isso, você cria um método que possui esse mesmo &quot;trabalho&quot; a ser feito? Utilizar cache é basicamente armazenar um trabalho já feito para ser reaproveitado.</p><p>Os ganhos? Performance claro, se aquele trabalho demorava 1s, usando cache pode chegar a demorar 5ms. Sim, é muito poderoso. E isso nos leva a redução de custos, na aplicação e no banco de dados, pois a ideia é reduzir as chamadas ao banco também.</p><p>Não existe uma estratégia pronta para isso, quem define é você. Mas o direcionamento do pensamento é: posso reutilizar um trabalho já feito para as próximas requisições? Um exemplo prático e simples: um blog possui uma sessão de &quot;mais visualizados&quot;, para isso, é preciso pegar todas as publicações e ordena-las pelo número de views. A cada requisição você realmente precisa fazer isso? Ou pode armazenar esse trabalho durante um tempo? Então utilize cache por 30m por exemplo. Pode confiar, os ganhos são infinitos!</p><p>Falando de cache em alta performance, eu focaria em duas opções: <a href="https://redis.io/">Redis</a> ou <a href="https://memcached.org/">Memcached</a>. Existem outras alternativas, mas eu iria com um deles, e entre os dois: Redis. Além de mais performático, ele possui diversas <a href="https://aws.amazon.com/elasticache/redis-vs-memcached/">outras vantagens</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/0*kQ6e5RiTDZXnmk5o.png" /><figcaption><a href="http://oldblog.antirez.com/post/redis-memcached-benchmark.html">Fonte do benchmark</a></figcaption></figure><p><strong>Bônus</strong>: utilizando <a href="https://github.com/phpredis/phpredis">essa extensão</a> do Redis para PHP, você tem ainda mais poder de otimização e assume o controle total do Redis de forma fácil e eficiente. É possível, por exemplo, armazenar suas sessões do PHP no Redis, ou seja, não precisa mais se preocupar com a performance do storage da aplicação, sua aplicação vai voar! :)</p><h3>8. Conexões persistentes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rh12RHye10_Tv3fLUwpqpA.png" /></figure><p>Esse é um assunto que vi sendo abordado poucas vezes, quando o assunto é performance. Conexões persistentes são <strong>muito poderosas</strong> para trabalhar em alta volumetria.</p><p>Na verdade, ouvimos falar sobre <a href="https://en.wikipedia.org/wiki/HTTP_persistent_connection">conexões http persistentes</a>, mas elas não são as únicas que sua aplicação precisa lidar. Temos também ao banco de dados e ao Redis, por exemplo.</p><p>Vou utilizar a do banco de dados como exemplo. Lembra do <a href="#5b3e"><strong>php-fpm</strong></a> que gerencia seus processos? Certo! Vamos pensar que ele processou as 10 mil requisições que configuramos e que todas as requisições precisaram ir ao banco de dados duas vezes. Com uma conexão tradicional, apenas uma seria aberta para realizar as duas queries, show! Mas pensando em um ambiente macro, nessas 10 mil requisições teríamos que fazer isso 10 mil vezes!</p><p>O recurso computacional exigido nesse processo, tanto da aplicação, quanto do banco de dados é de se levar em consideração. Com isso, podemos utilizar as conexões persistentes e reaproveitar uma conexão já aberta para esse processo e com certeza ter um ganho expressivo em recursos e performance, claro.</p><p>E para utilizar é bem simples, basta passar o parâmetro de configuração PDO::ATTR_PERSISTENT ao driver de conexão como true. Para saber um pouco mais vale conferir a <a href="https://www.php.net/manual/en/pdo.connections.php">documentação oficial</a>.</p><p>Caso queira ler um pouco mais, vou deixar um <a href="https://www.valinv.com/dev/mysql-mysql-persistent-connections-in-php">link interessante aqui</a> sobre conexões persistentes ao banco de dados.</p><p>Ao utilizar o Redis com <a href="https://github.com/phpredis/phpredis#pconnect-popen">PhpRedis</a> <em>(o mais recomendado)</em>, basta mudar a forma de conectar para $redis-&gt;pconnect() , simples assim!</p><h3>9. Funções nativas</h3><p>Bom, todos sabemos que <a href="https://www.php.net/manual/en/indexes.functions.php">elas existem</a>. Mas realmente usamos? <a href="https://www.exakat.io/top-100-php-functions/">Aqui tem um top 100</a> das funções nativas mais utilizadas em projetos open source. Não quero entrar no mérito se foram bem utilizadas ou não, mas é um ranking interessante para analisar quais são mais utilizadas e dar um primeiro passo.</p><p>Hoje em dia, eu quase nunca utilizo loops na mão. Isso porque consigo resolver quase tudo com funções nativas, que são mais performáticas. Elas também ajudam bastante quando pensamos em manutenção de código, pois facilitam o entendimento na hora de ler.</p><p>Um teste rápido, qual você consegue entender mais rápido?</p><pre>// Job</pre><pre>function cube($number) {</pre><pre>    return ($number * $number * $number);</pre><pre>}</pre><pre>// Without native</pre><pre>$cubes = [];</pre><pre>foreach($numbers as $number) {</pre><pre>    $cubes[] = cube($number);</pre><pre>}</pre><pre>// With native</pre><pre>$cubes = array_map(&#39;cube&#39;, $numbers);</pre><p>Fiz um <a href="https://gist.github.com/leocarmo/4a1320da1b61523c0c8d00ef2a3524e3">benchmark rápido</a> com esse código, e utilizando array_map consegui um resultado quase 15% mais performático, testando um array com 1.000.000 elementos 1.000 vezes.</p><p>Uma outra solução que gosto bastante é utilizar <a href="https://laravel.com/docs/7.x/collections">Laravel Collections</a>. O código fica mais limpo e legível, além de utilizar diversas funções nativas &quot;por baixo&quot;.</p><h3>10. Preloading</h3><p>O PHP 7.4 veio com uma novidade bem bacana, o preloading do <a href="#9c93">OPcache</a>, que falamos ali em cima. Resolvi falar sobre isso separadamente para entrar um pouco mais no detalhe, e por serem coisas diferentes mas complementares.</p><p><strong>E qual a diferença, na prática, em usar esse preloading?</strong></p><p>Como já sabemos, a principal característica do OPcache é armazenar os arquivos já compilados <em>(&quot;opcodes&quot;)</em> em memória para serem reutilizados. Certo, já falamos sobre isso. Mas ele faz isso sem relacionar tudo que foi compilado e não consegue resolver dependências entre as classes quando chegar uma requisição, ou seja, já está tudo em memória, mas quando uma classe herda outra, essa relação precisa ser vinculada.</p><p>Sendo assim, a cada requisição, ele precisa vincular as dependências entre as classes em tempo de execução. Lembra do ponto em reaproveitar trabalho? Bom, se podemos reaproveitar, podemos ganhar performance!</p><p>Para implementar esse preloading, alguns frameworks já trazem alguma solução pronta, como por exemplo o <a href="https://symfony.com/blog/new-in-symfony-4-4-preloading-symfony-applications-in-php-7-4">Symfony</a>.</p><p>Mas nada que não possa ser feito em outro framework. Basicamente é apontar um arquivo de preload no seu .ini dentro das configurações do OPcache.</p><pre>opcache.preload=/path/to/project/preload.php</pre><p>E dentro deste arquivo, carregar todo o seu projeto.</p><pre>$files = require &#39;vendor/composer/autoload_classmap.php&#39;;<br><br>foreach (array_unique($files) as $file) {<br>    opcache_compile_file($file);<br>}</pre><p>Bom, neste exemplo iríamos carregar o projeto todo. Para iniciar não é ruim, mas tendo em mente que é preciso melhorar.</p><p>Nosso projeto não utiliza TODOS os arquivos e TODAS classes que temos, então qual motivo de carregar tudo?</p><p>Aqui tem uma thread para se adicionar o preloading no composer de forma nativa, <a href="https://github.com/composer/composer/issues/7777#issuecomment-440268416">mas tem um comentário</a> bem bacana sobre os ganhos de fazer um preloading apenas das classes mais utilizadas no projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C91Dshr5tNN-MswyVVGkTA.png" /></figure><p>Com isso, da para ter uma ideia do custo/benefício de cada abordagem. Eu recomendo o preloading apenas das classes principais. Mas, você pode começar fazendo do projeto todo para ter um ganho inicial.</p><p>Até o momento, ainda não utilizei <a href="https://github.com/DarkGhostHunter/Preloader">esta lib</a>, mas achei bem interessante a ideia e pretendo utilizar. Quando fizer, coloco aqui os resultados.</p><p><a href="https://stitcher.io/blog/preloading-in-php-74">Aqui tem um artigo</a> bacana sobre esse assunto, onde você pode se aprofundar um pouco mais.</p><p><strong>Bônus</strong>: como falamos sobre o composer, não vou abrir uma sessão exclusiva pra isso, acho que podemos resumir rapidamente o que precisa ser feito para otimizá-lo. Na <a href="https://getcomposer.org/doc/articles/autoloader-optimization.md">documentação oficial</a> tem os detalhes, então para instalar seu projeto em produção utilize estas instruções:</p><pre><em>/</em>usr<em>/</em>bin<em>/</em>composer install <em>--</em>no-dev <em>-</em>o <em>-</em>a</pre><h3>11. Generators</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZX3-V1Kb5PhRNPQT" /></figure><p>Essa também é uma ferramenta bem poderosa que temos, não apenas no PHP, mas em todo o ecossistema de desenvolvimento. Na <a href="https://www.php.net/manual/en/language.generators.overview.php">documentação oficial</a>, temos um detalhamento melhor sobre isso, mas podemos resumir em dois itens:</p><ul><li>É uma forma simples de escrever <a href="https://www.php.net/manual/en/language.oop5.iterations.php">iterators</a></li><li>É possível iterar dados sem precisar construir um array em memória</li></ul><p>Com isso em mente, e ainda analisando a documentação oficial, temos um exemplo de implementação de um range() que vou fazer uma alteração para ilustrar melhor a ideia:</p><pre>// range nativo<br>foreach (range(1, 1_000_000) as $number) {<br>    echo $number . PHP_EOL;<br>}<br><br>// range com generator<br>function xrange(int $start, int $end) {<br>    for ($i = $start; $i &lt;= $end; $i++) {<br>        yield $i;<br>    }<br>}<br><br>foreach (xrange(1, 1_000_000) as $number) {<br>    echo $number . PHP_EOL;<br>}</pre><p>Se você tentar rodar esse código, pode ser que você receba um: Fatal error: Allowed memory size <em>(dependendo da sua configuração no .ini).</em></p><p>Na implementação nativa do range, por ele tentar alocar em memória 1M de integers, você pode explodir seu script por falta de memória. O que no xrange não ocorre, pois ele alocou apenas 1. Sim, isso mesmo, apenas 1.</p><blockquote>Que diferença hein?!</blockquote><p>Isso ocorre pois o retorno vai <em>&quot;passo a passo&quot;,</em> retornando um generator para que o foreach o execute um a um. É uma prática bem comum utilizar essa técnica ao ler arquivos bem grandes.</p><p>Bom, acho que ja é possível entender os ganhos até aqui de se utilizar essa técnica. Foi pensando nisso que o <a href="https://laravel.com/">Laravel</a> implementou as <a href="https://laravel.com/docs/master/collections#lazy-collections">LazyCollections</a>, por exemplo.</p><blockquote>Mas os generators vão além disso. E é aqui que tudo começa a ficar bem mais interessante! Os generators abrem as portas para se trabalhar com corrotinas utilizando PHP. Sim, muito maneiro! E isso já existe desde a versão 5.5.</blockquote><p>Aqui o assunto começa a ficar mais complexo, e tudo bem, não é fácil entender tudo isso logo de cara... É uma forma diferente de manipular e interagir com o estado de uma aplicação, então, antes de avançar, recomendo que você entenda melhor este e outros termos que vamos começar a utilizar daqui pra frente, e como tudo isso se relaciona.</p><p>Para isso, vou deixar um roteiro de artigos aqui para você:</p><ol><li><a href="https://www.treinaweb.com.br/blog/concorrencia-paralelismo-processos-threads-programacao-sincrona-e-assincrona/">Introdução teórica a estes termos</a></li><li><a href="https://thephp.website/br/edicao/voce-achou-que-sabia-sobre-generators/">Entendendo mais sobre generators</a></li><li><a href="https://nikic.github.io/2012/12/22/Cooperative-multitasking-using-coroutines-in-PHP.html">Corrotinas com generators</a></li></ol><h3>12. Código assíncrono</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*P6VdvlS47efZ738-.jpg" /></figure><p>Bom, a partir daqui, podemos assumir que você já entende a teoria sobre processos assíncronos. Então, nada melhor do que começar a colocar isso em prática!</p><p>Existem muitas formas de começar, mas quero usar uma abordagem pensando em como melhorar algum serviço que você já tenha funcionando em produção, sem precisar mudar framework ou uma grande quantidade de código.</p><blockquote>Antes de iniciar de fato no <strong>código assíncrono</strong>, queria apenas pontuar a diferença de se utilizar <strong>jobs assíncronos</strong>. Não quero entrar muito no detalhe, vou deixar a <a href="https://laravel.com/docs/master/queues">documentação do Laravel</a> sobre isso, tem bastante conteúdo lá. Também é algo extremamente recomendado ao se pensar em performance, então caso você não conheça, comece a utilizar!</blockquote><p>Para colocar a mão na massa, queria introduzir a utilização <a href="https://github.com/spatie/async">desta biblioteca</a>, já utilizei e gostei bastante. Ela resolve um problema clássico onde você precisa buscar dados em diferentes lugares mas eles não são dependentes, ou seja, é possível busca-los ao mesmo tempo e reduzir o tempo de resposta da aplicação.</p><p>A documentação é bem bacana, tem diversos exemplos e é bem simples de se utilizar. Com pouco código, já é possível conseguir bons resultados, e o melhor, sem precisar alterar todo seu sistema.</p><pre>use Spatie\Async\Pool;<br><br>$pool = Pool::create();<br><br>foreach ($things as $thing) {<br>    $pool-&gt;add(function () use ($thing) {<br>        // Do a thing<br>    })-&gt;then(function ($output) {<br>        // Handle success<br>    })-&gt;catch(function (Throwable $exception) {<br>        // Handle exception<br>    });<br>}<br><br>$pool-&gt;wait();</pre><p>Claro, isso é uma abordagem bem inicial. <a href="https://stitcher.io/blog/asynchronous-php">Aqui tem uma publicação</a> que fala um pouco dessa primeira abordagem e o problema que ela quer resolver. Criar sistemas é assim, saber utilizar a ferramenta correta para resolver um problema específico, e mesmo assim as possibilidades são amplas. Então saiba escolher o que utilizar e quando utilizar!</p><h3>13. Non-blocking I/O com PHP</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1ydd7abk6gxCOE2u.jpg" /></figure><p>Pode falar, título maneiro né? E sim, muitos programadores realmente duvidam que isso existe no PHP, além de existir é muito poderoso!</p><p>As primeiras soluções encontradas ao se iniciar nesse assunto no PHP é o <a href="https://amphp.org/">Apm</a> e o <a href="https://reactphp.org/">ReactPHP</a>. Sim, vamos falar sobre eles aqui, mas calma, tem <em>Swoorpresa</em>!</p><p>Basicamente essas implementações seguem a <a href="https://en.wikipedia.org/wiki/Reactor_pattern">Reactor Design Pattern</a>, implementando uma arquitetura orientada a eventos, realizando operações I/O de forma não bloqueante, utilizando um <a href="https://reactphp.org/event-loop/">event loop</a> como core.</p><p>Com esse event loop, um mar de possibilidades é aberto, podemos implementar servidor http, por exemplo, onde a utilização do Nginx se torna opcional, e não mais obrigatória para rodar seu código.</p><p>Para iniciar um Hello World no ReactPHP é bem simples, na <a href="https://reactphp.org/">página inicial da documentação</a> já tem um exemplo bacana. Caso você queira começar a explorar mais sobre ele, a documentação tem bastante conteúdo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*61hnMHENxQ3m72qNTMPeVw.png" /><figcaption>Hello World com ReactPHP</figcaption></figure><p>Mas estamos aqui para falar de um framework que entrega o maior nível de performance para aplicações PHP: o <a href="https://www.swoole.co.uk/">Swoole</a>. Sou um pouco suspeito para falar sobre este assunto, pois quando conheci foi amor a primeira vista. Ele é realmente incrível. Os citados acima também são interessantes, acho que vale a pena conhecer, mas se for para escolher, com certeza vou de Swoole!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/989/0*MgQlPN8ZoSadJcfp.png" /><figcaption>Funcionamento do PHP-FPM + Nginx vs. Swoole</figcaption></figure><p>Uma das coisas que achei sensacional foi o suporte nativo de múltiplos cores de CPU e <a href="https://www.swoole.co.uk/docs/modules/swoole-multiprocessing">multiprocessamento</a> (<a href="https://pt.wikipedia.org/wiki/Multiprocessamento">?</a>), dando mais poder para o Swoole.</p><p>Também é possível <a href="https://www.swoole.co.uk/docs/modules/swoole-process-pool">gerenciar um conjunto de processos</a> de forma muito fácil. Vamos pensar em um caso de uso real. Você vai realizar diversas operações em um Redis, para isso você precisa de uma conexão. Para extrair o máximo de performance, é recomendado realizar um pool de conexões e reutiliza-las. Como fazer isso então?</p><p>Primeiro, precisamos iniciar estas conexões. Faremos isso quando um worker do Swoole for iniciado (WorkerStart), assim não prejudicamos o tempo das requisições que vão chegar, pois faremos isso antes do worker estar pronto. Iremos utilizar o <a href="https://www.swoole.co.uk/docs/modules/swoole-coroutine-channel">Swoole Coroutine Channel</a> para compartilhar as conexões abertas entre as requisições.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/276fc32bffc4ee10f6ec70c8e0b89a6b/href">https://medium.com/media/276fc32bffc4ee10f6ec70c8e0b89a6b/href</a></iframe><blockquote>Eu comecei a estudar o Swoole fazendo um framework, ainda não finalizei, quando terminar vou escrever um artigo sobre ele. Tudo isso já estará implementado de um forma bem bacana para te ajudar nos estudos.</blockquote><p>Neste exemplo acima, podemos ainda implementar um <a href="https://www.swoole.co.uk/docs/modules/swoole-timer">Timer</a>, que de tempos em tempos valida se todas as conexões estão ativas, caso não esteja, ele renova automaticamente sem afetar uma requisição. Dando mais poder para nossa aplicação.</p><p>Tudo isso se baseando nas <a href="https://www.swoole.co.uk/docs/modules/swoole-coroutine">Swoole Coroutines</a>, onde ao escrever um código no <em>&quot;estilo síncrono&quot;</em>, temos todo o poder do async I/O non-blocking proporcionado pelo Swoole, sem precisar ficar escrevendo callbacks e awaits pelo código.</p><p>O Swoole muda bastante o comportamento do PHP, por exemplo ao reutilizar tudo que foi alocado em memória entre as requisições, antes de utilizar em produção, leia <strong>MUITO</strong> sobre essa e outras mudanças de comportamento para não enfrentar problemas.</p><p>É possível rodar aplicações <a href="https://github.com/swooletw/laravel-swoole">Laravel</a> e <a href="https://www.swoole.co.uk/article/symfony-swoole">Symfony</a> em cima do Swoole de forma fácil. É bom para começar a entender como ele funciona, mas para atingir a máxima performance, não é o recomendado. Para isso, temos frameworks próprios, por exemplo o <a href="https://www.easyswoole.com/En/Preface/introduction.html">easySwoole</a>.</p><p>Na documentação oficial, existe uma <a href="https://www.swoole.co.uk/articles">seção de artigos</a> explicando algumas implementações, caso queira se aprofundar mais tem coisa bem bacana por lá.</p><p>Bom, por enquanto vamos ficando por aqui. Com todas essas dicas, acredito que suas aplicações vão realmente atingir resultados incríveis usando PHP.</p><p><strong>Depois me conta se essas dicas fizeram efeito nos seus projetos e o quanto isso te ajudou!</strong></p><blockquote><strong>E ai, gostou? Faltou algum assunto importante?</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0a3ca9aed10" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>