{"id":49921,"date":"2026-03-10T17:02:43","date_gmt":"2026-03-10T20:02:43","guid":{"rendered":"https:\/\/www.hostinger.com\/pt\/tutoriais\/benchmarks-n8n\/"},"modified":"2026-03-10T17:02:43","modified_gmt":"2026-03-10T20:02:43","slug":"benchmarks-n8n","status":"publish","type":"post","link":"\/pt\/tutoriais\/benchmarks-n8n","title":{"rendered":"Benchmarks n8n: testando o uso real de recursos da ferramenta"},"content":{"rendered":"<p>Se voc&ecirc; est&aacute; hospedando o n8n por conta pr&oacute;pria, provavelmente j&aacute; se fez a mesma pergunta que eu: quantos recursos do servidor meus workflows do n8n realmente consomem?<\/p><p>Afinal, garantir recursos suficientes &eacute; essencial para manter um bom desempenho. Ao mesmo tempo, ningu&eacute;m quer gastar mais do que o necess&aacute;rio em CPU ou mem&oacute;ria que acabar&atilde;o ficando ociosas.<\/p><p>Se voc&ecirc; pesquisar online, encontrar&aacute; recomenda&ccedil;&otilde;es diferentes &ndash; como usar um processador com um n&uacute;cleo e 2 GB de RAM. Mas isso levanta algumas d&uacute;vidas pr&aacute;ticas:<\/p><ul class=\"wp-block-list\">\n<li>Ser&aacute; que eu realmente preciso de tudo isso para um workflow simples?<\/li>\n\n\n\n<li>Se eu rodar dois workflows, preciso de um servidor duas vezes mais potente?<\/li>\n\n\n\n<li>O uso de recursos do n8n &eacute; previs&iacute;vel em cen&aacute;rios reais?<\/li>\n<\/ul><p>Para responder a essas perguntas, realizei uma s&eacute;rie de benchmarks n8n em cen&aacute;rios reais, medindo o consumo de CPU, mem&oacute;ria RAM e rede de diferentes workflows do n8n em condi&ccedil;&otilde;es variadas.<\/p><h2 class=\"wp-block-heading\" id=\"h-adiantando-as-principais-conclusoes\">Adiantando as principais conclus&otilde;es<\/h2><p>Antes de entrarmos nos detalhes mais espec&iacute;ficos, aqui est&atilde;o os principais pontos que tirei do meu teste:<\/p><ul class=\"wp-block-list\">\n<li><strong>O consumo de recursos depende do n&oacute;<\/strong>. N&oacute;s que interagem com fontes externas, como o n&oacute; de requisi&ccedil;&atilde;o HTTP, consomem mais recursos de E\/S de rede do que n&oacute;s que executam tarefas localmente. No entanto, a RAM &eacute; o recurso dominante em praticamente todos os n&oacute;s, internos ou externos.<\/li>\n\n\n\n<li><strong>A escala &eacute;, em certa medida, linear. <\/strong>Executar v&aacute;rios fluxos de trabalho <em>id&ecirc;nticos<\/em> geralmente resulta em uma escalabilidade aproximadamente linear. Ao introduzir variedade de n&oacute;s, o uso de recursos torna-se muito menos previs&iacute;vel.<\/li>\n\n\n\n<li><strong>Atrasos n&atilde;o reduzem o pico de uso<\/strong>. Adicionar um intervalo entre as execu&ccedil;&otilde;es dos n&oacute;s n&atilde;o afeta o pico de uso. No entanto, isso permite distribuir a aloca&ccedil;&atilde;o de recursos ao longo do tempo, dando espa&ccedil;o para outros fluxos de trabalho.<\/li>\n\n\n\n<li><strong>Executar fluxos de trabalho em paralelo versus sequencialmente. <\/strong>N&atilde;o h&aacute; diferen&ccedil;a significativa no pico de utiliza&ccedil;&atilde;o de hardware entre a execu&ccedil;&atilde;o de fluxos de trabalho em paralelo e sequencialmente.<\/li>\n\n\n\n<li><strong>O modo de fila n8n n&atilde;o &eacute; nenhum segredo. <\/strong>Habilitar o modo de fila n8n praticamente dobra o uso b&aacute;sico de RAM, mesmo em modo ocioso. N&atilde;o reduz o consumo m&aacute;ximo em configura&ccedil;&otilde;es pequenas e s&oacute; faz sentido em grande escala.<\/li>\n<\/ul><h2 class=\"wp-block-heading\" id=\"h-metodologia-dos-benchmarks-n8n\">Metodologia dos benchmarks n8n<\/h2><p>Este teste de desempenho se concentrar&aacute; na <strong>utiliza&ccedil;&atilde;o m&aacute;xima de CPU, RAM<\/strong> e <strong>E\/S de rede<\/strong> do servidor host. <\/p><p>Vale ressaltar que existem outros benchmarks n8n. Por exemplo, a publica&ccedil;&atilde;o do blog <strong>n8n<\/strong> <strong>Scalability Benchmark<\/strong> examina como a plataforma lida com um grande volume de solicita&ccedil;&otilde;es, com foco em m&eacute;tricas como taxa de falhas e tempo de resposta. <\/p><p>No entanto, em vez de um benchmark sint&eacute;tico e controlado, concentrei-me na utiliza&ccedil;&atilde;o m&aacute;xima de recursos em cen&aacute;rios pr&aacute;ticos de automa&ccedil;&atilde;o no mundo real.<\/p><p><div class=\"editor\">\n                    <h4 class=\"title\">Dica de especialista<\/h4>\n                    <p>Se voc&ecirc; n&atilde;o tem certeza de qual plano VPS da Hostinger melhor se adapta &agrave;s suas necessidades, comece com o KVM 2 &ndash; ele oferece uma base s&oacute;lida e pode ser atualizado instantaneamente com um &uacute;nico clique &agrave; medida que suas necessidades aumentam.<\/p>\n                    <div class=\"d-flex mt-40\">\n                        <div class=\"author-photo\">\n                            <img decoding=\"async\" src=\"https:\/\/secure.gravatar.com\/avatar\/6defff471865605c4bd5f36d76b5fbc1e521823c2c646919933f35c5d866bbfa?s=65&d=mm&r=g\" width=\"65\" height=\"65\" class=\"border-radius-50\" alt=\"Editor\" \/>\n                        <\/div>\n                        <div class=\"mt-auto mb-auto\">\n                            <p class=\"author-name\">Minijus Savickas<\/p>\n                            <p class=\"author-position\">Chefe de produto VPS<\/p>\n                        <\/div>\n                    <\/div>\n                <\/div>\n\n\n\n<\/p><p>Vamos explorar a metodologia com mais detalhes, come&ccedil;ando por compreender o ambiente de teste. <\/p><h3 class=\"wp-block-heading\">Ambiente de teste e ferramentas utilizadas no benchmark n8n<\/h3><p>Segue abaixo a configura&ccedil;&atilde;o que utilizei para executar os testes de benchmark n8n:<\/p><ul class=\"wp-block-list\">\n<li><strong>Servidor:<\/strong> plano Hostinger VPS KVM 2<\/li>\n\n\n\n<li><strong>Sistema operacional:<\/strong> Ubuntu Linux 24.04 LTS<\/li>\n\n\n\n<li><strong>Ferramenta<\/strong> <strong>btop<\/strong> para monitoramento, <strong>Docker<\/strong> para executar o n8n em um cont&ecirc;iner.<\/li>\n<\/ul><p>Escolhi o Hostinger KVM 2 porque oferece recursos suficientes sem ser excessivamente caro. Com <strong>dois n&uacute;cleos de vCPU<\/strong>, <strong>8 GB de RAM<\/strong> e <strong>100 GB de armazenamento SSD NVMe<\/strong>, oferece ampla margem de seguran&ccedil;a caso os testes exijam. <\/p><p>Quanto ao sistema operacional, escolhi o <strong>Ubuntu 24.04 LTS<\/strong> simplesmente por ser est&aacute;vel, f&aacute;cil de usar e popular. Se voc&ecirc; usar uma distribui&ccedil;&atilde;o mais minimalista, poder&aacute; haver pequenas diferen&ccedil;as de desempenho, mas nada que comprometa significativamente a experi&ecirc;ncia do usu&aacute;rio. <\/p><p>Eu implementei o <strong>n8n no Docker<\/strong>. Essa &eacute; a abordagem de auto-hospedagem recomendada e, com o modelo VPS da Hostinger, instalar o n8n em um cont&ecirc;iner leva apenas alguns cliques. Eu tamb&eacute;m configurei o <strong>modo de fila n8n<\/strong> usando o modelo da Hostinger e suas configura&ccedil;&otilde;es padr&atilde;o predefinidas.<\/p><p><div class=\"protip\">\n                    <h4 class=\"title\">Pensando no overhead do Docker? &#128051;<\/h4>\n                    <p>O Docker tem desempenho pr&oacute;ximo ao nativo, j&aacute; que compartilha o kernel do host. Na pr&aacute;tica, a sobrecarga &eacute; insignificante em compara&ccedil;&atilde;o com a execu&ccedil;&atilde;o do n8n diretamente no host.<\/p>\n                <\/div>\n\n\n\n<\/p><p>Para monitoramento, utilizei o <strong>btop<\/strong> por ser simples e suficiente para coletar dados para este teste de desempenho. Tamb&eacute;m fornece um gr&aacute;fico que simplifica o processo de monitoramento. <\/p><h3 class=\"wp-block-heading\">Cen&aacute;rios de teste e m&eacute;tricas analisadas<\/h3><p>Para executar o teste de desempenho, realizei cada um dos seguintes testes em intervalos de 2 segundos durante v&aacute;rios minutos para garantir a consist&ecirc;ncia dos dados. Em alguns cen&aacute;rios, aumentei o intervalo para evitar os limites de taxa da API.<\/p><p>Para cada teste, registrei os valores de pico para:<\/p><ul class=\"wp-block-list\">\n<li><strong>utiliza&ccedil;&atilde;o da CPU<\/strong> <\/li>\n\n\n\n<li><strong>consumo de RAM<\/strong> <\/li>\n\n\n\n<li><strong>E\/S de rede<\/strong> <\/li>\n<\/ul><p><strong>Teste 1: benchmark por node<\/strong><\/p><p>Este teste isolou nodes individuais para responder &agrave; quest&atilde;o:<\/p><ul class=\"wp-block-list\">\n<li>Quanta CPU, RAM e largura de banda de rede um n&oacute; consome?<\/li>\n\n\n\n<li>Os n&oacute;s que interagem com servi&ccedil;os externos requerem mais recursos do que aqueles que s&atilde;o executados independentemente dentro do n8n?<\/li>\n\n\n\n<li>O consumo de recursos aumenta linearmente com o n&uacute;mero de n&oacute;s?<\/li>\n<\/ul><p><div><p class=\"important\"><strong>Importante! <\/strong>Para simplificar, chamarei de <strong>n&oacute;s externos<\/strong> os n&oacute;s que requerem intera&ccedil;&atilde;o com servi&ccedil;os externos e de <strong>n&oacute;s internos<\/strong> aqueles que s&atilde;o executados independentemente dentro do n8n. <\/p><\/div>\n\n\n\n<\/p><p><strong>Teste 2: benchmark de workflow &uacute;nico<\/strong><\/p><p>Este teste se concentra em fluxos de trabalho completos:<\/p><ul class=\"wp-block-list\">\n<li>Fluxo de trabalho simples com dois n&oacute;s internos.<\/li>\n\n\n\n<li>Fluxo de trabalho complexo com sete n&oacute;s internos<\/li>\n\n\n\n<li>Fluxo de trabalho complexo com um total de sete n&oacute;s, uma combina&ccedil;&atilde;o de n&oacute;s internos e externos.<\/li>\n\n\n\n<li>Efeito da adi&ccedil;&atilde;o de atrasos na execu&ccedil;&atilde;o<\/li>\n<\/ul><p><strong>Teste 3: m&uacute;ltiplos workflows na mesma inst&acirc;ncia<\/strong><\/p><p>Este teste analisou: <\/p><ul class=\"wp-block-list\">\n<li>O consumo de CPU, RAM e tr&aacute;fego aumenta linearmente com o n&uacute;mero de fluxos de trabalho id&ecirc;nticos?<\/li>\n\n\n\n<li>O consumo de recursos &eacute; previs&iacute;vel com base no n&uacute;mero e tipo de fluxos de trabalho em execu&ccedil;&atilde;o?<\/li>\n\n\n\n<li>A altern&acirc;ncia entre a execu&ccedil;&atilde;o de m&uacute;ltiplos fluxos de trabalho &eacute; uma estrat&eacute;gia vi&aacute;vel para minimizar picos de consumo de recursos?<\/li>\n<\/ul><p><strong>Teste 4: benchmark do queue mode<\/strong><\/p><p>Queria verificar o impacto do <a href=\"\/pt\/tutoriais\/n8n-queue-mode\" data-wpel-link=\"internal\" rel=\"follow\">modo de fila n8n<\/a> no consumo de recursos de um fluxo de trabalho:<\/p><ul class=\"wp-block-list\">\n<li>O modo de fila n8n ajuda a minimizar a utiliza&ccedil;&atilde;o de CPU, RAM e rede? Se sim, em quanto?<\/li>\n\n\n\n<li>Quais s&atilde;o as desvantagens de usar o modo de fila n8n, se houver?<\/li>\n\n\n\n<li>O modo de fila n8n &eacute; uma op&ccedil;&atilde;o vi&aacute;vel para executar fluxos de trabalho em um sistema de baixo custo?<\/li>\n<\/ul><p>Entre os testes, esperei at&eacute; que o uso de recursos retornasse a um n&iacute;vel pr&oacute;ximo ao normal para evitar resultados distorcidos.<\/p><p><div><p class=\"important\"><strong>Importante! <\/strong>Durante meus testes, houve casos em que o uso de RAM em modo ocioso divergiu significativamente da linha de base inicial. Neste caso, normalizei o valor para garantir que o resultado fosse consistente. Subtra&iacute; o novo valor de refer&ecirc;ncia do valor inicial e, em seguida, adicionei a diferen&ccedil;a ao resultado do teste de desempenho da RAM. Por exemplo, se a linha de base inicial for de 800 MB e a nova for de 824 MB, a diferen&ccedil;a ser&aacute; de -24. Isso significa que um uso de RAM de 900 MB ser&aacute; normalizado para 876 MB.<\/p><\/div>\n\n\n\n<\/p><h3 class=\"wp-block-heading\">Limita&ccedil;&otilde;es e ressalvas para o benchmark<\/h3><p>Este teste comparativo visa refletir o uso real dos fluxos de trabalho n8n, mas diversos fatores influenciam os resultados:<\/p><ul class=\"wp-block-list\">\n<li><strong>Varia&ccedil;&atilde;o do n&oacute;<\/strong>. Existem centenas de n&oacute;s n8n com comportamentos diferentes, que podem consumir recursos de maneira distinta daqueles que testei.<\/li>\n\n\n\n<li><strong>Ambiente de hospedagem<\/strong>. O ambiente de hospedagem e a configura&ccedil;&atilde;o que utilizo para implantar o n8n s&atilde;o relativamente minimalistas. Voc&ecirc; poder&aacute; experimentar uma sobrecarga de desempenho maior ou menor, dependendo do tipo de servidor, sistema operacional ou m&eacute;todo de implanta&ccedil;&atilde;o que utilizar.<\/li>\n\n\n\n<li><strong>L&oacute;gica de fluxo de trabalho<\/strong>. Os fluxos de trabalho neste benchmark s&atilde;o simples e n&atilde;o envolvem l&oacute;gica complexa. Se seus fluxos de trabalho processam grandes quantidades de dados ou arquivos, espere uma maior utiliza&ccedil;&atilde;o de recursos.<\/li>\n\n\n\n<li><strong>Escala de implanta&ccedil;&atilde;o.<\/strong> Eu utilizo fluxos de trabalho com menos de 10 n&oacute;s para executar o teste. Utilizar mais n&oacute;s aumenta o consumo de recursos.<\/li>\n<\/ul><p>Com isso em mente, vamos alinhar nossas expectativas: este teste n&atilde;o &eacute; uma solu&ccedil;&atilde;o universal que determina o requisito m&iacute;nimo exato de hardware para o seu fluxo de trabalho n8n. <\/p><p>A sua experi&ecirc;ncia pode variar dependendo do uso e da configura&ccedil;&atilde;o do equipamento. Em vez de usar o resultado do teste como padr&atilde;o, considere-o como um guia para entender o comportamento real do n8n, o que ajudar&aacute; voc&ecirc; a planejar melhor seu ambiente de hospedagem e sua estrat&eacute;gia de escalonamento.<\/p><h2 class=\"wp-block-heading\" id=\"h-resultados-dos-benchmarks-n8n\">Resultados dos benchmarks n8n<\/h2><p>Aqui est&aacute; o resultado do meu teste de benchmarks n8n com diferentes cen&aacute;rios de teste.<\/p><h3 class=\"wp-block-heading\">Benchmark n8n em n&iacute;vel de node<\/h3><p>Antes de executar qualquer n&oacute;, verifiquei o consumo de recursos do servidor em estado ocioso para estabelecer uma linha de base.<\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521984271\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903364-0.png\" alt=\"Gr&aacute;fico do consumo de recursos n8n em estado ocioso\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>Sem nenhum n&oacute; ou fluxo de trabalho ativo, o n8n consumiu <strong>0%<\/strong> <strong>da CPU <\/strong>e <strong>860 MB de RAM<\/strong>. A <strong>E\/S de rede <\/strong>atingiu apenas alguns bytes ou um d&iacute;gito de kilobytes, ent&atilde;o a normalizei para zero por ser insignificante. <\/p><p>Em seguida, executei o teste com estes fluxos de trabalho:<\/p><ol class=\"wp-block-list\">\n<li>Um fluxo de trabalho com um &uacute;nico n&oacute; interno do <strong>Code<\/strong> que gerou 1.000 n&uacute;meros decimais aleat&oacute;rios usando JavaScript.<\/li>\n\n\n\n<li>Um fluxo de trabalho com dois n&oacute;s internos de <strong>c&oacute;digo<\/strong> id&ecirc;nticos, ambos gerando 100 n&uacute;meros decimais aleat&oacute;rios.<\/li>\n\n\n\n<li>Um fluxo de trabalho com um &uacute;nico n&oacute; <strong>&ldquo;Obter Linha&rdquo;<\/strong> do Google Sheets que buscava dados de uma coluna de uma planilha.<\/li>\n\n\n\n<li>Um fluxo de trabalho com dois n&oacute;s do <strong>Google Sheets<\/strong>, um para extrair dados e outro para gravar dados.<\/li>\n<\/ol><p>O consumo de recursos para todos os testes, em compara&ccedil;&atilde;o com o estado ocioso, &eacute; o seguinte:<\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f352198473c\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903370-1.png\" alt=\"Um gr&aacute;fico do uso de CPU em n&iacute;vel de n&oacute; no benchmark n8n mostra que a utiliza&ccedil;&atilde;o da CPU aumenta com o n&uacute;mero de n&oacute;s.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521984bc9\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903378-2.png\" alt=\"Um gr&aacute;fico do benchmark de uso de RAM e rede em n&iacute;vel de n&oacute; n8n, mostrando que a utiliza&ccedil;&atilde;o de RAM e rede aumenta com o n&uacute;mero e o tipo de n&oacute;s.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>Os resultados foram os esperados: o consumo de recursos aumentou quando adicionei mais n&oacute;s. Dito isso, o comportamento de escala n&atilde;o foi linear nem previs&iacute;vel. <\/p><p>Por exemplo, um n&oacute; interno aumentou o uso de RAM em <strong>9 MB <\/strong>em rela&ccedil;&atilde;o ao estado ocioso. Ao inserir o mesmo n&oacute;, no entanto, a utiliza&ccedil;&atilde;o de mem&oacute;ria aumentou em<strong> 5 MB<\/strong>. Esse comportamento tamb&eacute;m foi observado nos n&oacute;s externos. <\/p><p>No que diz respeito aos n&oacute;s externos, eles de fato impunham uma carga de E\/S de rede maior, chegando a ser at&eacute; <strong>10<\/strong> vezes maior que a dos n&oacute;s internos. O uso da rede tamb&eacute;m aumentou significativamente quando adicionei o segundo n&oacute; externo, ao contr&aacute;rio da CPU e da RAM. <\/p><h3 class=\"wp-block-heading\">Benchmark n8n para um &uacute;nico fluxo de trabalho<\/h3><p>Ap&oacute;s entender o comportamento do n&oacute; isoladamente, quis verificar como um fluxo de trabalho real se comporta. Segue uma lista dos fluxos de trabalho que utilizei:<\/p><ol class=\"wp-block-list\">\n<li>Fluxo de trabalho simples com <strong>dois n&oacute;s internos exclusivos <\/strong>para gerar 100 n&uacute;meros inteiros aleat&oacute;rios e calcular a m&eacute;dia.<\/li>\n\n\n\n<li>Fluxo de trabalho complexo com<strong> sete n&oacute;s internos exclusivos <\/strong>para gerar dados aleat&oacute;rios e executar diversas opera&ccedil;&otilde;es, como normaliza&ccedil;&atilde;o.<\/li>\n\n\n\n<li>Fluxo de trabalho simples com <strong>dois n&oacute;s externos distintos<\/strong> que buscam dados de uma planilha do Google e os gravam em outro documento.<\/li>\n\n\n\n<li>Fluxo de trabalho complexo com <strong>sete n&oacute;s internos e externos exclusivos<\/strong>, cuja tarefa &eacute; obter dados de VPS via API, filtr&aacute;-los com base em regras e registr&aacute;-los em uma planilha do Google quando os crit&eacute;rios forem atendidos.<\/li>\n<\/ol><p>Aqui est&atilde;o os resultados para todos os cen&aacute;rios de teste acima:<\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521984f2e\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903381-3.png\" alt=\"Um gr&aacute;fico do uso da CPU em n&iacute;vel de benchmark de fluxo de trabalho n8n, mostrando que adicionar um n&oacute; diferente afeta o uso da CPU mais do que inserir um n&oacute; id&ecirc;ntico.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f35219852f0\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903387-4.png\" alt=\"Um gr&aacute;fico do benchmark de uso de RAM e rede em n&iacute;vel de fluxo de trabalho n8n, mostrando que adicionar um n&oacute; diferente afeta o uso de RAM e rede mais do que inserir um n&oacute; id&ecirc;ntico.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>Os resultados mostram que adicionar um novo n&oacute; exclusivo aumentar&aacute; o consumo de recursos mais do que inserir um n&oacute; id&ecirc;ntico. Isso &eacute; comum tanto em fluxos de trabalho simples quanto complexos, sugerindo que a utiliza&ccedil;&atilde;o de recursos de um fluxo de trabalho depende da variedade de seus n&oacute;s.<\/p><p>O comportamento de consumo de recursos neste segundo teste tamb&eacute;m parece consistente com o nosso teste em n&iacute;vel de n&oacute;: n&oacute;s externos afetam significativamente a utiliza&ccedil;&atilde;o de E\/S da rede, enquanto os internos n&atilde;o. <\/p><p>Em seguida, adicionei um atraso de 2 segundos usando o n&oacute; Wait nos fluxos de trabalho complexos para verificar se a interrup&ccedil;&atilde;o da execu&ccedil;&atilde;o reduz o consumo de recursos. <\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f352198556d\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903394-5.png\" alt=\"Um gr&aacute;fico do benchmark em n&iacute;vel de fluxo de trabalho com espera de dois segundos, mostrando o resultado de que uma execu&ccedil;&atilde;o n&atilde;o afeta a utiliza&ccedil;&atilde;o m&aacute;xima de recursos.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>O pico de consumo diminuiu ligeiramente, mas podemos afirmar com seguran&ccedil;a que a diferen&ccedil;a &eacute; insignificante. Dito isso, o intervalo ajuda a liberar recursos em um momento espec&iacute;fico, como mostra este gr&aacute;fico. <\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f352198618a\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903402-6.jpg\" alt=\"Gr&aacute;fico de utiliza&ccedil;&atilde;o do btop de um fluxo de trabalho com atraso de execu&ccedil;&atilde;o, mostrando que o atraso distribui o pico de utiliza&ccedil;&atilde;o de recursos.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><h3 class=\"wp-block-heading\">Benchmark n8n para m&uacute;ltiplos workflows<\/h3><p>Neste teste, executei v&aacute;rias inst&acirc;ncias dos mesmos quatro fluxos de trabalho usados na se&ccedil;&atilde;o anterior. Eis o cen&aacute;rio:<\/p><ol class=\"wp-block-list\">\n<li>Executar <strong>duas inst&acirc;ncias do mesmo fluxo de trabalho<\/strong> em paralelo. Adicionei mais uma inst&acirc;ncia, caso os recursos e o limite de requisi&ccedil;&otilde;es da API permitissem.<\/li>\n\n\n\n<li><strong>Alternar a execu&ccedil;&atilde;o de fluxos de trabalho id&ecirc;nticos<\/strong> por meio da execu&ccedil;&atilde;o dos subn&oacute;s. Em outras palavras, ap&oacute;s a conclus&atilde;o do primeiro fluxo de trabalho, a segunda inst&acirc;ncia &eacute; executada.<\/li>\n\n\n\n<li><strong>Executar diferentes fluxos de trabalho<\/strong> em paralelo. Executei um fluxo de trabalho interno simples em paralelo com um fluxo de trabalho complexo.<\/li>\n<\/ol><p>Vamos come&ccedil;ar por verificar os resultados dos testes do <strong>primeiro cen&aacute;rio<\/strong>, focando-nos nos fluxos de trabalho simples com dois n&oacute;s:<\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521986576\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903412-7.png\" alt=\"Um gr&aacute;fico do uso da CPU no benchmark de m&uacute;ltiplos fluxos de trabalho simples n8n, mostrando que a execu&ccedil;&atilde;o de um fluxo de trabalho adicional n&atilde;o aumenta o pico de uso de recursos de forma linear.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521986893\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903421-8.png\" alt=\"Um gr&aacute;fico do benchmark simples de m&uacute;ltiplos fluxos de trabalho n8n, mostrando que a execu&ccedil;&atilde;o de um fluxo de trabalho adicional n&atilde;o aumenta o pico de uso de recursos de forma linear.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>Aconteceu um caso interessante. Para fluxos de trabalho simples com n&oacute;s internos, o uso de recursos foi de certa forma previs&iacute;vel:<\/p><ul class=\"wp-block-list\">\n<li>Uma das execu&ccedil;&otilde;es atingiu um pico de <strong>17% <\/strong>de<strong> carga da CPU <\/strong>e <strong>815 MB de RAM<\/strong>.<\/li>\n\n\n\n<li>Duas execu&ccedil;&otilde;es atingem um pico de <strong>20% de carga da CPU<\/strong> e <strong>865 MB de RAM<\/strong>.<\/li>\n\n\n\n<li>Tr&ecirc;s execu&ccedil;&otilde;es atingem um pico de<strong> 27% de carga da CPU<\/strong> e <strong>912 MB de RAM<\/strong>.<\/li>\n<\/ul><p>Com base na an&aacute;lise, uma execu&ccedil;&atilde;o adicional do fluxo de trabalho adicionou aproximadamente <strong>40 a 50 MB<\/strong> de uso de RAM, e o uso da CPU aumentou de forma um tanto linear. <\/p><p>Entretanto, os fluxos de trabalho simples com n&oacute;s externos apresentaram comportamento de uso e escalabilidade imprevis&iacute;vel. A diferen&ccedil;a na utiliza&ccedil;&atilde;o de recursos ao executar uma, duas e tr&ecirc;s inst&acirc;ncias &eacute; aleat&oacute;ria, apesar de apresentar uma tend&ecirc;ncia de alta. <\/p><p>Agora, vejamos como se comportaram os<strong> fluxos de trabalho complexos<\/strong> com sete n&oacute;s:<\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521986cec\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903432-9.png\" alt=\"Um gr&aacute;fico do uso da CPU no benchmark de m&uacute;ltiplos fluxos de trabalho complexos n8n, mostrando que a execu&ccedil;&atilde;o de um fluxo de trabalho adicional n&atilde;o aumenta o pico de uso de recursos de forma linear.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521986f89\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903444-10.png\" alt=\"Um gr&aacute;fico do benchmark de fluxo de trabalho m&uacute;ltiplo complexo n8n mostrando o uso de RAM e rede, demonstrando que a execu&ccedil;&atilde;o de um fluxo de trabalho adicional n&atilde;o aumenta o pico de uso de recursos de forma linear.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>O comportamento do fluxo de trabalho simples foi consistente. A utiliza&ccedil;&atilde;o de fluxos de trabalho com n&oacute;s internos foi relativamente linear e previs&iacute;vel. Entretanto, os fluxos de trabalho com uma combina&ccedil;&atilde;o de n&oacute;s internos e externos apresentaram utiliza&ccedil;&atilde;o flutuante, inclusive na E\/S de rede. <\/p><p>No <strong>segundo cen&aacute;rio<\/strong>, encadeei dois fluxos de trabalho id&ecirc;nticos usando o n&oacute; de execu&ccedil;&atilde;o de subfluxo de trabalho. Isso me permitiu execut&aacute;-las em uma ordem alternativa. O resultado &eacute; o seguinte:<\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f35219876f3\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903455-11.png\" alt=\"Um gr&aacute;fico do benchmark de m&uacute;ltiplos fluxos de trabalho n8n com uso de CPU em execu&ccedil;&atilde;o alternada, mostrando que a mudan&ccedil;a da execu&ccedil;&atilde;o paralela para a alternada n&atilde;o impacta o pico de consumo de recursos.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521987ae1\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903465-12.png\" alt=\"Um gr&aacute;fico do benchmark de m&uacute;ltiplos fluxos de trabalho n8n com uso alternado de RAM e rede, mostrando que a mudan&ccedil;a da execu&ccedil;&atilde;o paralela para a alternada n&atilde;o impacta o pico de consumo de recursos.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>Como podemos ver, a utiliza&ccedil;&atilde;o permaneceu relativamente inalterada. No entanto, a utiliza&ccedil;&atilde;o da CPU para fluxos de trabalho internos complexos quase dobrou quando executados em ordem linear em compara&ccedil;&atilde;o com a execu&ccedil;&atilde;o em paralelo. <\/p><p>Da mesma forma, a sa&iacute;da de rede dos fluxos de trabalho externos, quando executados em ordem linear, apresentou uma queda significativa em compara&ccedil;&atilde;o com a execu&ccedil;&atilde;o em paralelo. <\/p><p><div class=\"protip\">\n                    <h4 class=\"title\">O que esses resultados nos dizem? &#128172;<\/h4>\n                    <p>Al&eacute;m dos dois casos mencionados, a utiliza&ccedil;&atilde;o de hardware de fluxos de trabalho executados em paralelo e em ordem linear n&atilde;o &eacute; t&atilde;o diferente. A menor produ&ccedil;&atilde;o de rede da execu&ccedil;&atilde;o alternativa pode ser devido ao fluxo de trabalho atingir o limite de taxa da API, o que significa que n&atilde;o h&aacute; dados para trocar. A menor entrada de rede, embora n&atilde;o t&atilde;o significativa, tamb&eacute;m indica um problema de limite de taxa. N&atilde;o consigo encontrar uma explica&ccedil;&atilde;o plaus&iacute;vel para o fato de a execu&ccedil;&atilde;o alternativa resultar em um aumento de quase 100% no uso da CPU. Dado que todos os outros testes mostram que a utiliza&ccedil;&atilde;o da CPU permanece a mesma ou ligeiramente inferior quando os fluxos de trabalho s&atilde;o executados em ordem linear, isto pode ser uma anomalia. <\/p>\n                <\/div>\n\n\n\n<\/p><p>Em seguida, testei o<strong> terceiro cen&aacute;rio<\/strong> executando um fluxo de trabalho interno simples em paralelo com um fluxo de trabalho interno complexo. <\/p><p>Conforme discutido anteriormente, um fluxo de trabalho interno simples consumiu aproximadamente<strong> 50 MB de RAM<\/strong> e <strong>7% da utiliza&ccedil;&atilde;o da CPU<\/strong>. Em compara&ccedil;&atilde;o, um fluxo de trabalho interno complexo aumentou o uso da <strong>CPU<\/strong> em <strong>cerca de 4%<\/strong> e exigiu <strong>40 MB adicionais de RAM<\/strong>. <\/p><p>Se o uso do n8n fosse linear, executar esses fluxos de trabalho em paralelo aumentaria o <strong>uso<\/strong> da <strong>CPU<\/strong> em aproximadamente <strong>11%<\/strong> e utilizaria <strong>90 MB adicionais de RAM<\/strong>. No entanto, isso n&atilde;o ocorreu, como mostram os resultados dos meus testes:<\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521987d6a\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903475-13.png\" alt=\"Um gr&aacute;fico do comportamento de escalabilidade de dois fluxos de trabalho n&atilde;o id&ecirc;nticos, mostrando que o consumo de uso do fluxo de trabalho n8n n&atilde;o escala linearmente.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>Com base nesses dados, duvido que possamos prever o pico de utiliza&ccedil;&atilde;o de recursos em v&aacute;rios fluxos de trabalho diferentes. Para fluxos de trabalho id&ecirc;nticos, ainda &eacute; poss&iacute;vel prever a utiliza&ccedil;&atilde;o do hardware, desde que o n&oacute; n&atilde;o varie significativamente. <\/p><h3 class=\"wp-block-heading\">Teste de desempenho n8n com queue mode<\/h3><p>O modo de fila n8n distribui suas tarefas de automa&ccedil;&atilde;o entre v&aacute;rios trabalhadores. Isso permite que cada processo seja executado independentemente da inst&acirc;ncia principal do n8n, ajudando a descarregar tarefas e a melhorar a escalabilidade.<\/p><p>Teoricamente, o modo de fila deve melhorar a estabilidade da sua automa&ccedil;&atilde;o ao executar um grande n&uacute;mero de fluxos de trabalho. Com isso em mente, quis executar novamente os fluxos de trabalho anteriores no modo de fila para verificar se a utiliza&ccedil;&atilde;o de recursos difere. Os cen&aacute;rios de teste s&atilde;o:<\/p><ol class=\"wp-block-list\">\n<li>Executando um <strong>fluxo de trabalho simples com dois n&oacute;s internos distintos<\/strong>. Em seguida, executei uma nova inst&acirc;ncia do mesmo fluxo de trabalho em paralelo, at&eacute; tr&ecirc;s execu&ccedil;&otilde;es simult&acirc;neas.<\/li>\n\n\n\n<li>Executar um <strong>fluxo de trabalho simples com dois n&oacute;s externos distintos<\/strong>, adicionando uma nova inst&acirc;ncia do mesmo fluxo de trabalho em paralelo, at&eacute; tr&ecirc;s execu&ccedil;&otilde;es simult&acirc;neas.<\/li>\n\n\n\n<li>Implementa&ccedil;&atilde;o de um <strong>fluxo de trabalho complexo com sete n&oacute;s internos<\/strong>. Adicionei uma nova inst&acirc;ncia do mesmo fluxo de trabalho, executando em paralelo, com at&eacute; tr&ecirc;s execu&ccedil;&otilde;es simult&acirc;neas.<\/li>\n\n\n\n<li>Executando um fluxo de trabalho <strong>simples com sete n&oacute;s internos e externos<\/strong>. Assim como nos cen&aacute;rios anteriores, adicionei uma nova inst&acirc;ncia do mesmo fluxo de trabalho em paralelo, com at&eacute; tr&ecirc;s execu&ccedil;&otilde;es simult&acirc;neas.<\/li>\n<\/ol><p>Surpreendentemente, meu teste mostrou que a utiliza&ccedil;&atilde;o b&aacute;sica de RAM foi o dobro do n&iacute;vel normal n8n, enquanto a E\/S da CPU e da rede permaneceram as mesmas. Isso pode ser devido ao n8n ter criado os trabalhadores. <\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f35219880b3\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903481-14.png\" alt=\"Um gr&aacute;fico comparando o uso de recursos do modo ocioso n8n normal versus o modo fila, mostrando que o modo fila consome uma quantidade significativa de RAM por padr&atilde;o.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>Agora, vamos examinar a utiliza&ccedil;&atilde;o de recursos dos <strong>fluxos de trabalho simples com dois n&oacute;s<\/strong> em execu&ccedil;&atilde;o no modo de fila n8n. <\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f352198824d\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903486-15.png\" alt=\"Um gr&aacute;fico do uso da CPU em fluxos de trabalho simples no modo de fila n8n mostra que a utiliza&ccedil;&atilde;o m&aacute;xima do hardware permanece alta.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f35219883d8\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903495-16.png\" alt=\"Um gr&aacute;fico do uso de RAM e rede em fluxos de trabalho simples no modo de fila n8n mostra que a utiliza&ccedil;&atilde;o m&aacute;xima do hardware permanece alta.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>Entretanto, este foi o uso de hardware de <strong>fluxos de trabalho complexos com sete n&oacute;s<\/strong> no modo de fila:<\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f352198860e\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903505-17.png\" alt=\"Um gr&aacute;fico do uso da CPU em fluxos de trabalho complexos no modo de fila n8n mostra que a utiliza&ccedil;&atilde;o m&aacute;xima do hardware permanece alta.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521988886\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903511-18.png\" alt=\"Um gr&aacute;fico do uso de RAM e rede em fluxos de trabalho complexos no modo de fila n8n mostra que a utiliza&ccedil;&atilde;o m&aacute;xima do hardware permanece alta.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>Contrariamente &agrave; minha cren&ccedil;a inicial, os resultados dos testes indicam que <strong>o modo de fila n8n n&atilde;o ajuda a reduzir o pico de utiliza&ccedil;&atilde;o de recursos<\/strong>. Embora minha observa&ccedil;&atilde;o sugira que o uso de hardware no modo de fila seja mais est&aacute;vel do que no n8n padr&atilde;o, o consumo m&eacute;dio &eacute; maior.<\/p><p><strong><div><p class=\"important\">Importante!<\/strong><\/p><p> Como configurei o modo de fila n8n usando o modelo VPS da Hostinger, o n&uacute;mero de workers foi definido como <strong>tr&ecirc;s<\/strong> por padr&atilde;o. Observe que o n&uacute;mero de trabalhadores afetar&aacute; o consumo de recursos e a execu&ccedil;&atilde;o do seu fluxo de trabalho. <\/p><\/div><\/p><p>\n\n\n<div><p class=\"important\"><strong>Importante! <\/strong>omo configurei o queue mode n8n usando o modelo VPS da Hostinger, o n&uacute;mero de workers foi definido como <strong>tr&ecirc;s<\/strong> por padr&atilde;o. Observe que o n&uacute;mero de trabalhadores afetar&aacute; o consumo de recursos e a execu&ccedil;&atilde;o do seu fluxo de trabalho.<\/p><\/div>\n\n\n\n<\/p><p>Ao adicionar mais execu&ccedil;&otilde;es de fluxo de trabalho, esperava que o efeito do modo de fila fosse mais aparente, mas n&atilde;o foi. Por exemplo, vamos comparar como v&aacute;rias execu&ccedil;&otilde;es de um <strong>fluxo de trabalho complexo com sete n&oacute;s internos<\/strong> se comportam no modo de fila e no modo padr&atilde;o:<\/p><div class=\"wp-block-image wp-block-image aligncenter size-large\"><figure data-wp-context='{\"imageId\":\"69f3521988f65\"}' data-wp-interactive=\"core\/image\" class=\"wp-lightbox-container\"><img decoding=\"async\" data-wp-class--hide=\"state.isContentHidden\" data-wp-class--show=\"state.isContentVisible\" data-wp-init=\"callbacks.setButtonStyles\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-on-async--load=\"callbacks.setButtonStyles\" data-wp-on-async-window--resize=\"callbacks.setButtonStyles\" src=\"\/br\/tutoriais\/wp-content\/uploads\/sites\/53\/2026\/03\/1770910903518-19.png\" alt=\"Um gr&aacute;fico da execu&ccedil;&atilde;o de m&uacute;ltiplos fluxos de trabalho nos modos normal e de fila, mostrando que n&atilde;o h&aacute; diferen&ccedil;a substancial entre as execu&ccedil;&otilde;es nos modos normal e de fila.\"><button class=\"lightbox-trigger\" type=\"button\" aria-haspopup=\"dialog\" aria-label=\"Ampliar\" data-wp-init=\"callbacks.initTriggerButton\" data-wp-on-async--click=\"actions.showLightbox\" data-wp-style--right=\"state.imageButtonRight\" data-wp-style--top=\"state.imageButtonTop\">\n\t\t\t<svg xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"12\" height=\"12\" fill=\"none\" viewbox=\"0 0 12 12\">\n\t\t\t\t<path fill=\"#fff\" d=\"M2 0a2 2 0 0 0-2 2v2h1.5V2a.5.5 0 0 1 .5-.5h2V0H2Zm2 10.5H2a.5.5 0 0 1-.5-.5V8H0v2a2 2 0 0 0 2 2h2v-1.5ZM8 12v-1.5h2a.5.5 0 0 0 .5-.5V8H12v2a2 2 0 0 1-2 2H8Zm2-12a2 2 0 0 1 2 2v2h-1.5V2a.5.5 0 0 0-.5-.5H8V0h2Z\"><\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure><\/div><p>Na vers&atilde;o padr&atilde;o do n8n, uma execu&ccedil;&atilde;o adicional desse fluxo de trabalho utilizava aproximadamente <strong>40 a 50 MB de RAM<\/strong>, enquanto no modo de fila, adicionava pelo menos <strong>60 MB<\/strong>. Ao executar tr&ecirc;s inst&acirc;ncias desse fluxo de trabalho, o consumo de RAM aumentou em mais de<strong> 100 MB<\/strong>. <\/p><p>Com base nos testes de desempenho, entendemos que <strong>o modo de fila n8n n&atilde;o &eacute; uma solu&ccedil;&atilde;o que magicamente permitir&aacute; executar uma carga de trabalho intensiva em uma m&aacute;quina de baixo desempenho<\/strong>. Na verdade, esse modo consome, em m&eacute;dia, mais hardware do que o n8n normal.<\/p><p>No entanto, se voc&ecirc; implantar centenas de fluxos de trabalho, o efeito do modo de fila poder&aacute; ser mais evidente. Geralmente &eacute; recomendado quando sua configura&ccedil;&atilde;o de automa&ccedil;&atilde;o apresenta problemas como webhooks lentos e lat&ecirc;ncia significativa, situa&ccedil;&otilde;es em que cargas de trabalho distribu&iacute;das podem ajudar a manter a simultaneidade. <\/p><h2 class=\"wp-block-heading\" id=\"h-o-que-os-benchmarks-n8n-mostram\">O que os benchmarks n8n mostram?<\/h2><p>Este teste foi concebido para fornecer uma estimativa aproximada de como os fluxos de trabalho n8n utilizam recursos. Como a amostra de dados de teste &eacute; pequena, o comportamento de utiliza&ccedil;&atilde;o de recursos pode mudar em grande escala ou quando outras vari&aacute;veis estiverem envolvidas. <\/p><p>Al&eacute;m disso, concentrei-me apenas na <strong>utiliza&ccedil;&atilde;o m&aacute;xima de RAM, CPU e E\/S de rede<\/strong>. Se, em vez disso, voc&ecirc; considerar m&eacute;dias e outras m&eacute;tricas, como o tempo de execu&ccedil;&atilde;o do fluxo de trabalho, o n8n poder&aacute; apresentar um comportamento diferente.<\/p><p><strong>Recomenda&ccedil;&atilde;o pr&aacute;tica<\/strong> <\/p><p>Se voc&ecirc; estiver come&ccedil;ando com 10 a 20 fluxos de trabalho, recomendo hosped&aacute;-los em um servidor com pelo menos <strong>4 GB de RAM<\/strong>. Mesmo que voc&ecirc; preveja que sua automa&ccedil;&atilde;o usar&aacute; menos de 4 GB, isso oferece margem de seguran&ccedil;a e garante a compatibilidade futura caso precise adicionar mais fluxos de trabalho.<\/p><p>Al&eacute;m disso, monitore de perto a utiliza&ccedil;&atilde;o de recursos e use um <a href=\"\/pt\/self-hosted-n8n\" data-wpel-link=\"internal\" rel=\"follow\">provedor de hospedagem n8n<\/a> que ofere&ccedil;a planos facilmente escal&aacute;veis, como a Hostinger. Dessa forma, voc&ecirc; pode adicionar mais recursos caso sua configura&ccedil;&atilde;o de automa&ccedil;&atilde;o precise de mais poder computacional do que o esperado. <\/p><figure class=\"wp-block-image size-large\"><a href=\"\/pt\/alojamento-vps\" target=\"_blank\" rel=\"noreferrer noopener\"><img decoding=\"async\" width=\"1024\" height=\"300\" src=\"https:\/\/blog.hostinger.io\/pt-tutoriais\/wp-content\/uploads\/sites\/26\/2023\/02\/BR-VPS-hosting_in-text-banner-1-1024x300.png\" alt=\"\" class=\"wp-image-32923\" srcset=\"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-content\/uploads\/sites\/26\/2023\/02\/BR-VPS-hosting_in-text-banner-1.png 1024w, https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-content\/uploads\/sites\/26\/2023\/02\/BR-VPS-hosting_in-text-banner-1-300x88.png 300w, https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-content\/uploads\/sites\/26\/2023\/02\/BR-VPS-hosting_in-text-banner-1-150x44.png 150w, https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-content\/uploads\/sites\/26\/2023\/02\/BR-VPS-hosting_in-text-banner-1-768x225.png 768w, https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-content\/uploads\/sites\/26\/2023\/02\/BR-VPS-hosting_in-text-banner-1-1536x450.png 1536w\" sizes=\"(max-width: 1024px) 100vw, 1024px\" \/><\/a><\/figure>\n","protected":false},"excerpt":{"rendered":"<p>Se voc&ecirc; est&aacute; hospedando o n8n por conta pr&oacute;pria, provavelmente j&aacute; se fez a mesma pergunta que eu: quantos recursos do servidor meus workflows do n8n realmente consomem? Afinal, garantir recursos suficientes &eacute; essencial para manter um bom desempenho. Ao mesmo tempo, ningu&eacute;m quer gastar mais do que o necess&aacute;rio em CPU ou mem&oacute;ria que [&#8230;]<\/p>\n<p><a class=\"btn btn-secondary understrap-read-more-link\" href=\"\/pt\/tutoriais\/benchmarks-n8n\">Read More&#8230;<\/a><\/p>\n","protected":false},"author":356,"featured_media":49922,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"rank_math_title":"Benchmarks n8n: testando o uso de recursos da ferramenta","rank_math_description":"Veja os benchmarks n8n em cen\u00e1rios reais e descubra quanto CPU, RAM e rede seus workflows consomem ao rodar em um servidor VPS.","rank_math_focus_keyword":"benchmarks n8n","footnotes":""},"categories":[4915],"tags":[],"class_list":["post-49921","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-vps"],"hreflangs":[{"locale":"pt-BR","link":"https:\/\/www.hostinger.com\/br\/tutoriais\/benchmarks-n8n\/","default":1},{"locale":"pt-PT","link":"https:\/\/www.hostinger.com\/pt\/tutoriais\/benchmarks-n8n\/","default":0}],"acf":[],"_links":{"self":[{"href":"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-json\/wp\/v2\/posts\/49921","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-json\/wp\/v2\/users\/356"}],"replies":[{"embeddable":true,"href":"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-json\/wp\/v2\/comments?post=49921"}],"version-history":[{"count":0,"href":"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-json\/wp\/v2\/posts\/49921\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-json\/wp\/v2\/media\/49922"}],"wp:attachment":[{"href":"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-json\/wp\/v2\/media?parent=49921"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-json\/wp\/v2\/categories?post=49921"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.hostinger.com\/pt\/tutoriais\/wp-json\/wp\/v2\/tags?post=49921"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}