Pular para o conteúdo principal

Principais comandos de ajuste de memória no V8 (Node.js)

· 3 min para ler
Leandro Andrade
Leandro Andrade
Software Developer

Os principais comandos para ajuste de memória da V8 no Node.js são:

--max-old-space-size=<MB>​

Define o tamanho máximo da geração antiga (Old Generation) da heap.

Usado caso a aplicação lide com grandes volumes de dados ou possui objetos que vivem por muito tempo (ex: cache, estruturas persistentes), aumentar esse valor pode evitar coletas de lixo frequentes e lentas.

Exemplo:

node --max-old-space-size=2048 app.js  # 2 GB

--max-semi-space-size=<MB>​

Define o tamanho da semi-space na (Young Generation). Como há duas semi-spaces (To/From), o total será o dobro.

Usado caso em plicações com muitos objetos de curta duração (como APIs de alta taxa de requisição) se beneficiam de mais espaço jovem para reduzir o custo de GC.

node --max-semi-space-size=32 app.js  # 32 MB por semi-space (64 MB total)

--max-heap-size=<MB>​

Define o tamanho máximo total da heap (engloba jovem + antiga + outros).

Usado quando você quer um limite superior de memória para evitar estouros (ex: em containers com pouca memória).

node --max-heap-size=3072 app.js  # Limita a heap total a 3 GB

Recomendações:

Tipo de aplicaçãoRecomendações
API com muitas requisiçõesAumente --max-semi-space-size para reduzir GCs curtos
Processamento de grandes dadosAumente --max-old-space-size para reduzir GCs longos
Execução em ambiente limitadoUse --max-heap-size para evitar travamentos por falta de RAM
Aplicação genérica em produçãoTeste valores em ambiente controlado com benchmarks

Exemplos de uso​

Execução direto no Node.js:

node --max-semi-space-size=32 --max-old-space-size=2048 benchmark.js

Configuração no container:

FROM node:20-slim

WORKDIR /app
COPY benchmark.js .

CMD ["node", "--max-semi-space-size=32", "--max-old-space-size=2048", "benchmark.js"]

Simulação​

Abaixo um exemplo de API usando fastify:

import Fastify from 'fastify';

const fastify = Fastify();

fastify.get('/simulate-load', async (request, reply) => {
  const data = [];
  for (let i = 0; i < 5_000_000; i++) {
    data.push({ id: i, text: `item-${i}` });
    if (i % 10000 === 0) data.length = 0; // simula uso temporário
  }

  const mem = process.memoryUsage();

  return {
    status: 'ok',
    message: 'Simulação completa',
    memory: {
      rss: formatMB(mem.rss),
      heapTotal: formatMB(mem.heapTotal),
      heapUsed: formatMB(mem.heapUsed),
      external: formatMB(mem.external),
    }
  };
});

function formatMB(bytes) {
  return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
}

fastify.listen({ port: 3000, host: '0.0.0.0' }, err => {
  if (err) {
    fastify.log.error(err);
    process.exit(1);
  }
  console.log('🚀 Servidor rodando em http://localhost:3000');
});

Exemplo de resposta da API:

{
  "status": "ok",
  "message": "Simulação completa",
  "memory": {
    "rss": "130.45 MB",
    "heapTotal": "96.00 MB",
    "heapUsed": "78.25 MB",
    "external": "3.12 MB"
  }
}
PropriedadeDescrição
rssMemória total alocada pelo processo Node.js, incluindo heap, buffers e código nativo.
heapTotalMemória total da heap JS alocada.
heapUsedQuantidade da heap efetivamente usada.
externalObjetos alocados fora da heap JS, como buffers.

Referências​