Como Configurar uma Aplicação Node.js para Produção no Ubuntu

Introdução

Executar uma aplicação Node.js localmente é apenas o primeiro passo. Para torná-la pronta para produção, você precisa configurá-la para condições do mundo real que exigem estabilidade, segurança e desempenho. Um ambiente de produção devidamente configurado garante que seu aplicativo possa se recuperar de falhas, atender ao tráfego de forma segura e lidar com o aumento da demanda sem tempo de inatividade.

Neste guia, você construirá uma configuração completa de produção no Ubuntu usando Node.js, PM2, Nginx, Let’s Encrypt e UFW. O Node.js executa a aplicação, o PM2 gerencia os processos e os reinicia automaticamente, o Nginx gerencia as requisições recebidas e serve o tráfego via HTTPS, o Let’s Encrypt fornece certificados SSL gratuitos, e o UFW protege o servidor controlando o acesso à rede. Juntas, essas ferramentas formam uma base sólida para implantar aplicações que são confiáveis, eficientes e seguras.

Implante suas aplicações Node a partir do GitHub usando a Plataforma de Aplicativos do Linux-Console.net. Deixe o Linux-Console.net cuidar da escalabilidade da sua aplicação.

Principais Pontos:

Use um gerenciador de processos como o PM2 para manter aplicativos Node.js rodando continuamente, reiniciar automaticamente em caso de falhas e iniciar na reinicialização usando pm2 startup e pm2 save.
Execute aplicativos atrás do Nginx como um proxy reverso em vez de expor o Node.js diretamente. O Nginx gerencia SSL, recursos estáticos e balanceamento de carga de maneira eficiente.
Sempre vincule o Node.js ao localhost (127.0.0.1) em produção para evitar acesso público direto e contar com o Nginx para tráfego externo.
Ative HTTPS com Let’s Encrypt e Certbot. Deixe o Nginx gerenciar a terminação SSL e a renovação de certificados automaticamente com sudo certbot renew --dry-run.
Proteja o servidor com UFW. Permita apenas o tráfego SSH e “Nginx Full” (HTTP/HTTPS), bloqueando todo o resto.
Gerencie segredos via variáveis de ambiente ou arquivos .env carregados pelo dotenv, e mantenha-os fora do controle de versão.
Ative a compressão e o cache no Nginx (gzip e Brotli) para melhorar a velocidade de carregamento e reduzir o uso de largura de banda.
Monitore com PM2 e ferramentas do sistema (pm2 monit, htop ou integração com ferramentas como Grafana/Prometheus) para detectar problemas de desempenho cedo.
Aplique atualizações e auditorias regularmente (sudo apt update && sudo apt upgrade, npm audit) para manter a segurança do sistema e das dependências.
Siga as melhores práticas, como executar sob um usuário não root, automatizar backups, rotação de logs e usar HTTPS em todos os lugares para uma implantação estável e segura.

Pré-requisitos

Este guia presume que você possui o seguinte:

Uma configuração de servidor Ubuntu, conforme descrito na configuração inicial do servidor com Ubuntu. Você deve ter um usuário não root com privilégios de sudo e um firewall ativo.
Um nome de domínio apontado para o IP público do seu servidor. Este tutorial usará o nome de domínio example.com ao longo do texto.
Nginx instalado, conforme abordado no guia Como Instalar e Configurar o Nginx no Ubuntu.
Nginx configurado com SSL usando certificados Let’s Encrypt. Como garantir o Nginx com Let’s Encrypt no Ubuntu irá guiá-lo pelo processo.

Quando você tiver concluído os pré-requisitos, terá um servidor servindo a página de espaço reservado padrão do seu domínio em https://example.com/.

Instalar e Verificar o Node.js

Nesta etapa, você instalará o Node.js usando o NodeSource PPA e verificará se a instalação foi bem-sucedida. Este método garante que você tenha acesso à versão de Suporte a Longo Prazo (LTS) mais recente do Node.js e ao seu gerenciador de pacotes associado, o npm.

Instalar Node.js via PPA do NodeSource

Primeiro, instale o PPA do NodeSource para ter acesso ao seu repositório. Certifique-se de que você está no seu diretório home e use curl para baixar o script de instalação da versão LTS mais recente do Node.js.

cd ~

curl -sL https://deb.nodesource.com/setup_24.x -o nodesource_setup.sh

Você pode revisar o conteúdo do script com nano antes de executá-lo:

nano nodesource_setup.sh

Quando estiver pronto, execute o script com sudo:

sudo bash nodesource_setup.sh

Isso adicionará o PPA à sua configuração e atualizará automaticamente o cache de pacotes local.

Agora, você pode instalar o Node.js:

sudo apt install nodejs

Para verificar a instalação e conferir a versão do Node.js, execute:

node -v

Você deve ver uma saída semelhante a esta:

v24.11.1

Instale o npm e os pacotes build-essential

O pacote nodejs também instala o npm, o gerenciador de pacotes do Node.js. Para confirmar que ele está instalado e inicializar seu arquivo de configuração, execute:

npm -v

Você deve ver uma saída semelhante:

11.6.2

Para que alguns pacotes npm funcionem (aqueles que exigem compilar código a partir da fonte, por exemplo), você precisará instalar o pacote build-essential:

sudo apt install build-essential

Com o Node.js e o npm instalados com sucesso, você agora possui as ferramentas necessárias para desenvolver e gerenciar as dependências da sua aplicação. Na próxima seção, você criará um aplicativo Node.js simples para testar o ambiente de execução.

Criar um aplicativo de exemplo em Node.js

Vamos escrever uma aplicação simples em Node.js que retorna “Hello World” para qualquer requisição HTTP. Este aplicativo de exemplo verificará se o Node.js está instalado corretamente e demonstrará como os aplicativos devem ser configurados para escutar de forma segura no localhost em produção.

Crie um servidor Node.js simples

Crie um novo arquivo chamado hello.js no seu diretório home:

cd ~

nano hello.js

Adicione o seguinte código ao arquivo:

const http = require('http');

const hostname = 'localhost';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World!\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Salve e feche o arquivo quando terminar.

Este script cria um servidor HTTP simples que escuta na porta 3000 e responde com Hello World! a qualquer requisição recebida. Como está vinculado a localhost, ele aceitará conexões apenas da mesma máquina.

Testar o aplicativo

Execute seu aplicativo usando Node.js:

node hello.js

Você deve ver uma saída semelhante a:

Server running at http://localhost:3000/

Em outra sessão do terminal, teste seu aplicativo com curl:

curl http://localhost:3000

Você deve ver a seguinte saída:

Hello World!

Se você não obtiver o resultado esperado, certifique-se de que sua aplicação Node.js está em execução e configurada para escutar no endereço e porta corretos.

Quando tiver certeza de que está funcionando, encerre o aplicativo pressionando CTRL+C no terminal original para parar o servidor.

Por que os aplicativos devem se conectar ao localhost em produção

Em ambientes de produção, aplicações Node.js normalmente ficam atrás de um proxy reverso, como o Nginx. A aplicação Node.js escuta em um endereço interno (como localhost:3000), enquanto o Nginx gerencia o tráfego web de entrada, a terminação TLS e o roteamento.

Vincular sua aplicação a localhost oferece vários benefícios de segurança e confiabilidade:

Evita exposição externa: Apenas o Nginx pode acessar diretamente o processo Node.js.
Habilita o descarregamento de HTTPS: O Nginx gerencia certificados SSL e criptografia, transferindo esse trabalho do Node.js.
Simplifica as regras do firewall: O firewall pode bloquear o acesso a todas as portas de aplicativos internas, permitindo apenas HTTP/HTTPS.

Essa configuração garante que seu aplicativo Node.js seja isolado, seguro e acessível apenas através do proxy reverso Nginx.

Instalar e Configurar o Gerenciador de Processos PM2

Nesta seção, você instalará o PM2, um gerenciador de processos de produção para aplicações Node.js. O PM2 permite que você mantenha suas aplicações funcionando continuamente, reinicie-as automaticamente após falhas e configure-as para iniciar junto com o sistema.

Instalando o PM2

Use o npm para instalar o PM2 globalmente:

sudo npm install -g pm2

A flag -g instala o PM2 no sistema todo, tornando-o disponível para todos os usuários e aplicações.

Uma vez instalado, inicie seu aplicativo de teste usando o PM2:

pm2 start hello.js

Você verá uma tabela de saída que mostra que o PM2 começou a gerenciar seu aplicativo:

[PM2] Spawning PM2 daemon with pm2_home=/home/user/.pm2
[PM2] PM2 Successfully daemonized
[PM2] Starting /root/nodeapp/hello.js in fork_mode (1 instance)
[PM2] Done.
┌────┬──────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name     │ namespace   │ version │ mode    │ pid      │ uptime │ ↺    │ status    │ cpu      │ mem      │ user     │ watching │
├────┼──────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0  │ hello    │ default     │ N/A     │ fork    │ 3826     │ 0s     │ 0    │ online    │ 0%       │ 33.3mb   │ root     │ disabled │
└────┴──────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘

Como indicado acima, o PM2 atribui automaticamente um nome do app (com base no nome do arquivo, sem a extensão .js) e um id do PM2. O PM2 também mantém outras informações, como o PID do processo, seu status atual e o uso de memória.

Habilitando Reinício Automático em Caso de Falha e Reboot

O PM2 reinicia automaticamente sua aplicação se ela travar ou for encerrada. Para garantir que o próprio PM2 seja iniciado automaticamente quando o servidor for reiniciado, execute:

pm2 startup systemd

O PM2 gerará um comando que se parecerá com isto (substitua sammy pelo seu nome de usuário):

[PM2] To setup the Startup Script, copy/paste the following command:
sudo env PATH=$PATH:/home/sammy/.nvm/versions/node/v24.11.1/bin /home/sammy/.nvm/versions/node/v24.11.1/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy

Nota: Seu caminho pode variar dependendo da versão do Node.js e do nome de usuário.

Execute esse comando, depois salve seus aplicativos em execução para que o PM2 os lembre no próximo reinício:

pm2 save

Para confirmar que tudo está configurado corretamente, verifique o status do serviço:

systemctl status pm2-sammy

Observação: Para uma visão detalhada do systemd, por favor, consulte Systemd Essentials: Trabalhando com Serviços, Unidades e o Jornal.

Se você encontrar problemas, reinicie seu servidor e verifique se seu aplicativo inicia automaticamente.

Usando o arquivo de ecossistema do PM2

Quando você estiver pronto para rodar mais de um aplicativo ou gerenciar diferentes ambientes, o arquivo de ecossistema do PM2 é de grande ajuda. É um arquivo de configuração simples que permite definir variáveis de ambiente, portas e configurações de implantação tudo em um só lugar.

Gere um arquivo inicial executando:

pm2 ecosystem

Então edite o arquivo ecosystem.config.js gerado:

module.exports = {
  apps: [
    {
      name: 'hello',
      script: 'hello.js',
      env: {
        NODE_ENV: 'development',
        PORT: 3001
      },
      env_production: {
        NODE_ENV: 'production',
        PORT: 3000
      }
    }
  ]
};

Para iniciar seu aplicativo no modo de produção, use:

pm2 start ecosystem.config.js --env production

O arquivo de ecossistema facilita o gerenciamento de múltiplos ambientes e o armazenamento seguro de variáveis de ambiente fora do seu código-fonte. Com o PM2 em funcionamento, seu aplicativo irá sobreviver a falhas, reinicializações e atualizações, tudo enquanto roda discretamente em segundo plano.

Comandos PM2 adicionais

Além daqueles que abordamos, o PM2 oferece muitos subcomandos que permitem gerenciar ou consultar informações sobre suas aplicações.

Pare um aplicativo com este comando (especifique o nome do App ou id no PM2):

pm2 stop app_name_or_id

Reiniciar um aplicativo:

pm2 restart app_name_or_id

Liste os aplicativos atualmente gerenciados pelo PM2:

pm2 list

Obtenha informações sobre um aplicativo específico usando seu nome do app:

pm2 info app_name

Para visualizar os logs ao vivo do seu aplicativo:

pm2 logs

O monitor de processos PM2 pode ser acessado com o subcomando monit. Isso exibe o status da aplicação, o uso da CPU e da memória:

pm2 monit

Observe que executar pm2 sem quaisquer argumentos também exibirá uma página de ajuda com exemplos de uso.

Agora que sua aplicação Node.js está em execução e gerenciada pelo PM2, vamos configurar o proxy reverso.

Configurar o Nginx como um Proxy Reverso

Com seu aplicativo Node.js rodando sob o PM2, o próximo passo é torná-lo acessível aos usuários pela web. Em vez de expor o aplicativo diretamente na porta 3000, você usará o Nginx como um proxy reverso. O Nginx irá lidar com todas as requisições HTTP e HTTPS que chegarem e repassá-las ao seu aplicativo Node.js rodando no localhost.

Configuração Básica de Proxy Reverso

Abra o arquivo de configuração do Nginx do seu site. Se você seguiu a configuração da seção de pré-requisitos, este arquivo deve estar localizado em /etc/nginx/sites-available/example.com:

sudo nano /etc/nginx/sites-available/example.com

Dentro do bloco server, localize (ou crie) a seção location / e substitua seu conteúdo pela seguinte configuração. Se seu aplicativo Node.js escuta em uma porta diferente, atualize o valor destacado de acordo.

server {
...
    listen 80;
    server_name example.com www.example.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
...
}

Isso instrui o Nginx a escutar na porta 80 (HTTP) e encaminhar todo o tráfego recebido para o seu aplicativo Node.js rodando na porta 3000.

Para testar vários aplicativos, você pode definir blocos location adicionais. Por exemplo, se você tiver outro aplicativo Node.js rodando na porta 3001, adicione isso ao mesmo bloco de servidor:

server {
...
    location /app2 {
        proxy_pass http://localhost:3001;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
...
}

Salve o arquivo e, em seguida, teste a configuração em busca de erros de sintaxe executando:

sudo nginx -t

Se tudo estiver correto, recarregue o Nginx:

sudo systemctl reload nginx

Neste ponto, visitar o domínio do seu servidor (por exemplo, http://example.com) deve carregar o aplicativo Node.js em execução através do proxy Nginx.

Adicionando Configuração HTTPS (SSL)

Para proteger seu aplicativo, configure o Nginx para lidar com o tráfego HTTPS. Se você já possui certificados SSL da Let’s Encrypt, certifique-se de que eles estejam definidos na configuração do Nginx. Aqui está um exemplo de como o bloco de servidor atualizado pode ficar:

server {
    listen 80;
    server_name example.com www.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name example.com www.example.com;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

O primeiro bloco de servidor redireciona automaticamente todas as requisições HTTP para HTTPS, e o segundo bloco lida com o tráfego seguro na porta 443.

Roteamento de Múltiplas Aplicações (Opcional)

Se o seu servidor hospeda múltiplas aplicações, o Nginx pode gerenciá-las todas definindo diferentes caminhos ou subdomínios. Por exemplo, você pode ter:

https://example.com/ redireciona para a porta 3000
https://example.com/app2 redireciona para a porta 3001
https://api.example.com/ redireciona para a porta 4000

Cada aplicativo pode ser gerenciado por seu próprio processo PM2 e servido através do Nginx.

Depois de confirmar que tudo está funcionando, seu aplicativo Node.js agora deve estar acessível com segurança através do Nginx.

Configure o Firewall UFW para Produção

Agora que seu aplicativo Node.js está rodando atrás do Nginx, vamos adicionar uma camada final de segurança de rede. O Ubuntu vem com um firewall integrado chamado UFW (Uncomplicated Firewall). Ele é leve, fácil de configurar e perfeito para bloquear acessos indesejados ao seu servidor.

Verificando o status do firewall

Antes de fazer qualquer alteração, verifique se o UFW já está ativado:

sudo ufw status

Se aparecer inativo, não se preocupe, nós o ativaremos em breve. Mas primeiro, definiremos quais tipos de tráfego devem ser permitidos. Sempre é melhor configurar as regras antes de ligá-lo.

Permitir Tráfego Essencial

No mínimo, você precisará permitir SSH para ainda poder se conectar ao seu servidor, e HTTP/HTTPS para que o Nginx possa servir o tráfego da web. Para fazer isso, execute os seguintes comandos:

sudo ufw allow OpenSSH

sudo ufw allow 'Nginx Full'

Agora podemos ativar o firewall:

sudo ufw enable

Você será solicitado a confirmar: digite y e pressione Enter.

Verifique o firewall novamente para ter certeza de que suas regras estão ativas:

sudo ufw status

Você deve ver algo assim:

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx Full                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx Full (v6)            ALLOW       Anywhere (v6)

É isso! Agora apenas o tráfego SSH e web é permitido; todo o resto está bloqueado.

Por Que um Firewall é Importante na Produção

Firewalls são fundamentais para a segurança do servidor porque estabelecem um controle rigoroso sobre qual tráfego de rede pode alcançar seu sistema. Mesmo aplicativos e servidores web bem configurados podem ser vulneráveis se portas desnecessárias permanecerem abertas.

Aqui estão algumas razões principais pelas quais os firewalls são essenciais na produção:

Minimize a exposição: Apenas portas explicitamente permitidas são acessíveis, reduzindo o número de vetores de ataque potenciais.
Contenção: No caso de uma violação ou configuração incorreta, um firewall limita até onde um invasor pode se mover dentro do seu sistema ou rede.
Conformidade e auditoria: Muitos padrões de segurança exigem proteção ativa de firewall com regras de acesso auditáveis.
Defesa em profundidade: Firewalls complementam outras camadas de segurança, como TLS, autenticação e fortalecimento de aplicações.

Para a maioria dos servidores de produção, manter um firewall ativo com apenas as portas essenciais abertas oferece o equilíbrio certo entre acessibilidade e proteção. É uma medida de segurança de baixa manutenção que fornece uma camada extra de controle e ajuda a prevenir o acesso não autorizado à rede.

Com o UFW configurado, seu sistema agora está mais seguro no nível de rede.

Ativar SSL com Let’s Encrypt

Agora que seu aplicativo está publicamente acessível através do Nginx, é hora de adicionar HTTPS para uma comunicação segura. O SSL criptografa todo o tráfego entre seu servidor e os usuários, garantindo privacidade e integridade dos dados. A maneira mais fácil de adicionar SSL ao seu site é usando o Let’s Encrypt, uma autoridade certificadora gratuita e automatizada.

Instale o Certbot e o plugin do Nginx

O Let’s Encrypt funciona através de uma ferramenta chamada Certbot, que gerencia todo o processo de solicitação, instalação e renovação de certificados. No Ubuntu, você pode instalar o Certbot junto com seu plugin para Nginx em uma única etapa:

sudo apt update

sudo apt install certbot python3-certbot-nginx -y

Isso instala tanto o cliente Certbot quanto seu plugin de integração com o Nginx, que configurará automaticamente o HTTPS no seu bloco de servidor Nginx existente.

Obter Certificados SSL

Uma vez que o Certbot esteja instalado, você pode usá-lo para solicitar um novo certificado SSL para o seu domínio. Substitua example.com e www.example.com pelos nomes reais do seu domínio:

sudo certbot --nginx -d example.com -d www.example.com

Durante o processo, o Certbot irá:

Verifique se seu domínio aponta para este servidor (usando um desafio HTTP)
Obtenha um certificado SSL da Let’s Encrypt
Edite automaticamente sua configuração do Nginx para habilitar o HTTPS
Recarregue o Nginx para que as novas configurações entrem em vigor

Você será solicitado a fornecer um endereço de e-mail (usado para notificações de renovação) e a concordar com os termos de serviço. Após a conclusão da configuração, você deverá ver uma mensagem de confirmação informando que seu certificado foi instalado com sucesso.

Você pode verificar os detalhes do seu certificado com:

sudo certbot certificates

Então, visite seu domínio para verificar se o site agora está sendo servido de forma segura.

Renovação Automática

Os certificados Let’s Encrypt são válidos por apenas 90 dias, mas não há necessidade de se preocupar com renovações manuais. O Certbot instala um temporizador do sistema que roda duas vezes por dia para verificar certificados que estão prestes a expirar e renová-los automaticamente.

Você pode testar este processo de renovação a qualquer momento com:

sudo certbot renew --dry-run

Se o teste for concluído sem erros, seus certificados serão renovados automaticamente em segundo plano, e o Nginx será recarregado para aplicar os novos.

Por Que o HTTPS é Importante

Executar sua aplicação sobre HTTPS não é mais opcional, é uma parte essencial de qualquer sistema em produção. SSL/TLS garante que toda a comunicação entre seu servidor e os clientes seja criptografada e à prova de adulteração, protegendo contra espionagem e manipulação de dados.

Além da segurança, o HTTPS oferece várias vantagens adicionais:

Confiança e credibilidade: Navegadores rotulam sites sem HTTPS como “Não Seguro”, o que pode comprometer a confiança do usuário.
Melhoria no ranking de busca: Os principais mecanismos de busca usam HTTPS como um sinal de classificação.
Acesso a recursos modernos da web: HTTP/2, QUIC e outras melhorias de desempenho requerem TLS.
Conformidade: Muitas regulamentações de privacidade e padrões da indústria exigem criptografia para dados transmitidos.

Ao usar o Let’s Encrypt, você obtém esses benefícios com configuração mínima e custo zero. Os certificados são renovados automaticamente, tornando-se uma solução fácil e de longo prazo para implantações seguras.

Com o HTTPS implementado, seu servidor agora está servindo tráfego criptografado e confiável.

Gerencie Variáveis de Ambiente de Forma Segura

Todo aplicativo em produção precisa de uma maneira confiável de gerenciar dados de configuração, como chaves de API, credenciais de banco de dados ou tokens secretos. Armazenar esses valores diretamente no seu código-fonte pode expô-los através do controle de versão, logs ou até mesmo vazamentos do lado do cliente. Uma abordagem mais segura é usar variáveis de ambiente, que mantêm informações sensíveis separadas do seu código.

Usando arquivos `.env` com `dotenv`

Um método comum e direto para gerenciar variáveis de ambiente no Node.js é usando um arquivo .env junto com o pacote dotenv. Essa configuração permite que sua aplicação leia valores de configuração em tempo de execução, mantendo-os fora do código-fonte.

Execute o seguinte para instalar o pacote dotenv:

npm install dotenv

Em seguida, crie um arquivo .env no diretório do seu projeto:

nano .env

Adicione seus valores de configuração em pares chave-valor, assim:

PORT=3000
NODE_ENV=production
DB_HOST=localhost
DB_USER=myuser
DB_PASS=securepassword
JWT_SECRET=myjwtsecretkey

Agora, modifique o arquivo principal da sua aplicação (por exemplo, app.js) para carregar as variáveis de ambiente na inicialização:

require('dotenv').config();

const express = require('express');
const app = express();

app.listen(process.env.PORT, () => {
  console.log(`Server running in ${process.env.NODE_ENV} mode on port ${process.env.PORT}`);
});

Quando seu aplicativo é executado, ele lê as variáveis definidas no arquivo .env e as usa para configurar o ambiente de execução.

Variáveis de Ambiente com PM2

Se você estiver executando sua aplicação com PM2, pode definir variáveis de ambiente diretamente nos comandos ou arquivos de configuração do PM2. Isso ajuda a manter as configurações consistentes entre ambientes como desenvolvimento, teste e produção.

Você pode definir variáveis diretamente ao iniciar um aplicativo:

pm2 start app.js --name "myapp" --env production

Para uma solução mais limpa e escalável, use o arquivo de configuração do ecossistema do PM2. Gere-o usando:

pm2 ecosystem

Então edite o arquivo ecosystem.config.js para incluir suas variáveis de ambiente:

module.exports = {
  apps: [
    {
      name: 'myapp',
      script: 'app.js',
      env: {
        NODE_ENV: 'development',
        PORT: 3001
      },
      env_production: {
        NODE_ENV: 'production',
        PORT: 3000,
        DB_HOST: 'localhost',
        DB_USER: 'myuser',
        DB_PASS: 'securepassword'
      }
    }
  ]
};

Inicie o aplicativo no modo de produção:

pm2 start ecosystem.config.js --env production

Isso garante que as variáveis corretas sejam carregadas automaticamente toda vez que o aplicativo reiniciar.

Melhores Práticas para Gerenciar Segredos

Gerenciar segredos e variáveis de ambiente de forma segura é fundamental para manter a integridade da sua infraestrutura. As seguintes melhores práticas ajudarão a minimizar os riscos:

Mantenha segredos fora do controle de versão: Nunca faça commit de arquivos .env no seu repositório Git. Adicione-os ao .gitignore para evitar exposição acidental.
Limitar acesso: Apenas usuários confiáveis e sistemas automatizados devem ter permissão para ler ou modificar arquivos de configuração do ambiente.
Use arquivos específicos para cada ambiente: Mantenha configurações separadas para desenvolvimento, testes, staging e produção. Por exemplo, .env.development e .env.production.
Altere os segredos regularmente: Troque chaves de API, tokens e senhas periodicamente para reduzir o impacto de possíveis vazamentos.
Use um gerenciador de segredos para sistemas maiores: Para aplicações complexas ou equipes, considere usar serviços como o HashiCorp Vault em vez de arquivos .env locais.
Evite registrar dados sensíveis: Tenha cuidado para não imprimir ou registrar segredos nos logs da sua aplicação ou implantação.
Validar variáveis de ambiente na inicialização: Use bibliotecas como joi ou env-schema para garantir que todas as variáveis necessárias estejam definidas antes que a aplicação seja executada.
Restringir permissões de arquivos: Use o comando chmod para limitar o acesso aos arquivos .env. Por exemplo:
```
chmod 600 .env
```

Seguir essas práticas ajuda a proteger informações sensíveis, evita exposições acidentais e facilita a gestão da configuração em múltiplos ambientes.

Técnicas de Otimização da Produção

Com sua aplicação em execução em um ambiente de produção estável, é importante focar em desempenho e eficiência. A otimização não apenas melhora a experiência do usuário, mas também reduz os custos com servidores e ajuda a garantir uma escalabilidade tranquila. Nesta seção, você aprenderá várias técnicas para ajustar seu ambiente Node.js e Nginx para ter mais velocidade, confiabilidade e melhor aproveitamento dos recursos.

Ativar Compressão (gzip ou Brotli)

A compressão é uma das maneiras mais simples de melhorar o desempenho. Ela reduz o tamanho dos arquivos enviados do servidor para o cliente, o que acelera o carregamento das páginas e diminui o consumo de largura de banda. O Nginx suporta dois métodos de compressão populares: gzip e Brotli.

Usando gzip

Para habilitar a compressão gzip, abra o arquivo de configuração principal do Nginx:

sudo nano /etc/nginx/nginx.conf

Dentro do bloco http, adicione ou descomente as seguintes diretivas:

gzip on;
gzip_types text/plain text/css application/javascript application/json application/xml;
gzip_min_length 256;
gzip_comp_level 5;

Essas configurações ativam o gzip para tipos de arquivos comuns, comprimem arquivos maiores que 256 bytes e aplicam um nível de compressão moderado para equilibrar a carga da CPU e o desempenho.

Usando Brotli

Se você tiver o módulo Brotli instalado, poderá usá-lo para obter ratios de compressão ainda melhores:

brotli on;
brotli_comp_level 5;
brotli_types text/plain text/css application/javascript application/json application/xml;

Brotli é particularmente eficaz para recursos baseados em texto, como CSS e JavaScript. Depois de fazer essas alterações, recarregue o Nginx para aplicá-las:

sudo systemctl reload nginx

Com a compressão ativada, os clientes farão o download dos recursos mais rapidamente, resultando em tempos de carregamento mais rápidos e melhor desempenho tanto em dispositivos desktop quanto móveis.

Configurar Cache no Nginx

O cache permite que seu servidor reutilize respostas geradas anteriormente, em vez de regenerá-las a cada solicitação. Isso reduz significativamente a carga em sua aplicação Node.js e acelera o tempo de resposta para os usuários finais.

Para armazenar em cache recursos estáticos, como imagens, folhas de estilo e scripts, adicione esta configuração ao seu bloco server do Nginx:

location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
    expires 7d;
    add_header Cache-Control "public, no-transform";
}

Essa configuração orienta os navegadores a armazenarem em cache os recursos estáticos por sete dias. Você pode ajustar a duração dependendo de com que frequência seus arquivos estáticos mudam.

Para APIs ou conteúdo dinâmico, o cache pode ser aplicado de forma mais seletiva. Por exemplo, você pode armazenar em cache respostas de endpoints acessados com frequência, enquanto exclui endpoints que retornam dados específicos do usuário. O Nginx também suporta microcaching (cache de curto prazo em segundos) para APIs de alto tráfego.

Melhores Práticas de Registro

Logs são essenciais para monitoramento, solução de problemas e otimização de desempenho. Tanto o PM2 quanto o Nginx oferecem ferramentas de registro abrangentes que ajudam a acompanhar o que está acontecendo em seu sistema.

Logs do PM2

O PM2 gerencia os logs da sua aplicação automaticamente. Para visualizá-los em tempo real, use:

pm2 logs

Com o tempo, os logs podem crescer e consumir espaço em disco. Para evitar isso, instale o módulo de rotação de logs do PM2:

pm2 install pm2-logrotate

Em seguida, configure a política de rotação:

pm2 set pm2-logrotate:max_size 10M

pm2 set pm2-logrotate:retain 7

Essa configuração mantém os arquivos de log com menos de 10 MB cada e mantém sete dias de logs. Você pode ajustar esses valores com base na sua capacidade de armazenamento e necessidades de registro.

Logs do Nginx

O Nginx mantém tanto os logs de acesso (registros de cada requisição) quanto os logs de erros (informações sobre problemas e falhas). Esses logs geralmente são armazenados em /var/log/nginx/.

Você pode revisar os logs de acesso manualmente ou gerar um relatório detalhado de tráfego usando ferramentas como goaccess:

sudo apt install goaccess

sudo goaccess /var/log/nginx/access.log -o /var/www/html/report.html --log-format=COMBINED

Este comando cria um relatório HTML interativo com métricas sobre a localização dos visitantes, volume de tráfego e tempos de resposta.

Logs bem gerenciados são essenciais para identificar gargalos de desempenho, solicitações com falha ou anomalias de segurança antes que afetem os usuários.

Gerenciamento de Recursos e Otimização do Node.js

Aplicações Node.js executam em um único thread por padrão. Para utilizar todos os núcleos de CPU disponíveis e melhorar a concorrência, você pode usar clustering e outras técnicas de gerenciamento de processos.

Usar Agrupamento

O PM2 pode iniciar automaticamente múltiplos processos Node.js para aproveitar CPUs com múltiplos núcleos:

pm2 start app.js -i max

Este comando inicia tantas instâncias do seu aplicativo quantos forem os núcleos de CPU do seu servidor. O PM2 gerenciará o balanceamento de carga e reiniciará os processos caso falhem.

Monitorar o Uso de Memória e CPU

Monitore regularmente o uso de recursos do seu aplicativo para evitar vazamentos de memória ou consumo excessivo de CPU:

pm2 monit

Isso abre um painel interativo mostrando métricas de memória e CPU em tempo real para cada processo.

Descarregar recursos estáticos para o Nginx

Deixe o Nginx servir arquivos estáticos diretamente em vez de encaminhá-los pelo Node.js. Isso reduz significativamente o uso da CPU no lado do Node.js e garante uma entrega mais rápida dos recursos em cache.

Configuração do Ambiente

Use variáveis de ambiente para ajustar configurações de desempenho, como detalhamento de logs, limites de taxa de API ou duração do cache. Gerenciar a configuração por meio de variáveis de ambiente mantém seu aplicativo flexível e mais fácil de escalar.

Monitoramento e Métricas

Após otimizar seu ambiente de produção, o próximo passo essencial é configurar o monitoramento eficaz e a coleta de métricas. O monitoramento oferece visibilidade sobre o desempenho da sua aplicação, a utilização de recursos e a saúde do sistema. Ele ajuda a detectar problemas cedo, acompanhar tendências de longo prazo e fazer melhorias baseadas em dados.

Vamos ver como você pode monitorar sua aplicação Node.js, o servidor web Nginx e os recursos do sistema usando ferramentas internas e serviços externos.

Por Que o Monitoramento é Importante

Em produção, cada segundo conta. Sem monitoramento, problemas de desempenho ou interrupções no serviço podem passar despercebidos até afetarem os usuários. O monitoramento ajuda você a:

Detecte falhas rapidamente e receba alertas automáticos quando elas ocorrerem.
Analise o desempenho do sistema sob diferentes cargas de tráfego.
Identifique pontos de extremidade lentos, gargalos ou vazamentos de memória.
Tome decisões informadas sobre escalabilidade e otimização.
Mantenha a disponibilidade e a confiabilidade em todas as implantações.

Uma configuração de monitoramento bem projetada inclui tanto o monitoramento em tempo real para alertas imediatos quanto as métricas históricas para análise de desempenho ao longo do tempo.

Monitorando Aplicações Node.js com PM2

PM2, o gerenciador de processos usado para executar seu aplicativo Node.js, inclui recursos poderosos de monitoramento.

Monitoramento em Tempo Real

Para obter uma visão geral dos processos em execução, use:

pm2 list

Isso exibe todos os aplicativos ativos juntamente com seu status, tempo de atividade, uso de CPU e memória. Para uma visualização mais detalhada e em tempo real, use:

pm2 monit

Isso abre um painel interativo mostrando métricas-chave de desempenho, como utilização de CPU e memória por processo. Monitorar essas métricas ajuda a detectar exaustão de recursos, processos descontrolados ou vazamentos de memória.

Monitoramento de Logs

O PM2 também oferece gerenciamento centralizado de logs. Para revisar os logs da sua aplicação, execute:

pm2 logs

Você pode visualizar os logs de um aplicativo específico usando:

pm2 logs myapp

Se você notar reinicializações frequentes, verifique a lista de processos do PM2 com:

pm2 status

Isso mostrará quantas vezes cada processo foi reiniciado, o que pode ser um indicador de erros ou falhas.

Monitoramento Avançado (PM2 Plus)

Para implantações maiores, o PM2 oferece o PM2 Plus, um painel baseado na web que acompanha métricas como uso de CPU, consumo de memória e tempo de atividade da aplicação em todos os servidores. Você pode configurar alertas para ultrapassagens de limites e visualizar tendências de desempenho ao longo do tempo.

O PM2 também pode se integrar com sistemas de monitoramento de terceiros populares como Datadog, New Relic e Prometheus para uma visibilidade unificada.

Monitorando Nginx

O Nginx fica na frente da sua pilha de produção, gerenciando solicitações HTTP e terminação SSL. Monitorar o Nginx é essencial para entender como os usuários interagem com seu sistema e quão eficientemente as solicitações estão sendo processadas.

Registros de Acesso e Erros

O Nginx registra cada requisição que ele processa no log de acesso, geralmente localizado em:

/var/log/nginx/access.log

Erros são registrados separadamente em:

/var/log/nginx/error.log

Você pode visualizar esses registros em tempo real:

sudo tail -f /var/log/nginx/access.log

Os logs de acesso mostram informações valiosas, como IPs dos clientes, tempos de resposta, códigos de status e agentes de usuário. Esses logs são úteis para identificar padrões como alta latência, erros 404 frequentes ou volumes de requisições fora do normal.

Para um relatório resumido e visual, você pode usar goaccess. Ele cria um painel interativo que destaca as fontes de tráfego, os endpoints mais populares e a distribuição de respostas.

Ativar Página de Status do Nginx

O Nginx inclui um módulo leve stub_status que expõe métricas ao vivo do servidor, como conexões atuais e contagem de requisições. Adicione o seguinte bloco à sua configuração do Nginx:

location /nginx_status {
    stub_status;
    allow 127.0.0.1;
    deny all;
}

Após recarregar o Nginx, você pode visualizar as métricas visitando:

http://localhost/nginx_status

Essas métricas podem ser integradas em painéis de monitoramento ou usadas para alertas automáticos.

Coletando Métricas de Aplicações em Node.js

Para um monitoramento mais detalhado no nível da aplicação, você pode coletar métricas personalizadas diretamente do seu aplicativo Node.js. Essas métricas podem acompanhar os tempos de resposta da API, taxas de requisições ou durações de consultas ao banco de dados.

Execute o seguinte comando para instalar a biblioteca cliente do Prometheus:

npm install prom-client express

Adicione um endpoint /metrics à sua aplicação:

const express = require('express');
const client = require('prom-client');
const app = express();

client.collectDefaultMetrics({ timeout: 5000 });

app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

app.listen(3000, () => {
  console.log('Metrics available at /metrics');
});

Você pode conectar este endpoint ao Prometheus ou ao Grafana para visualizar métricas como latência de requisições, uso de memória e desempenho da coleta de lixo.

Monitoramento em Nível de Sistema

Além do monitoramento de aplicações, fique de olho no desempenho geral do servidor. O Linux oferece várias ferramentas para esse propósito:

htop ou top: Exibe o uso de CPU e memória em tempo real.
iostat: Monitora as operações de entrada/saída do disco.
netstat ou ss: Exibe conexões de rede abertas.
vmstat: Monitora processos, memória e estatísticas de I/O.

Você pode automatizar o monitoramento do sistema usando ferramentas como Netdata, Glances ou Grafana Agent, que coletam métricas em toda a sua infraestrutura e as visualizam em dashboards.

Erros Comuns, Solução de Problemas e Melhores Práticas

Mesmo uma configuração de produção bem ajustada pode, ocasionalmente, enfrentar problemas. Compreender como identificar, diagnosticar e resolver essas questões é fundamental para manter a confiabilidade e reduzir o tempo de inatividade. Esta seção fornece etapas detalhadas de solução de problemas para erros comuns e descreve as melhores práticas para ajudá-lo a manter seu ambiente Node.js estável, seguro e fácil de manter a longo prazo.

Erros Comuns e Correções

1. Aplicativo não inicia com PM2

Causa: Caminhos de arquivo incorretos, dependências ausentes ou variáveis de ambiente mal configuradas.
Solução: Verifique os logs usando:
```
pm2 logs
```
Confirme se o caminho do arquivo correto está sendo usado na sua configuração do PM2. Reinstale as dependências, se necessário:
```
npm install --production
```
Também verifique se as variáveis de ambiente necessárias estão carregadas corretamente a partir do .env ou do arquivo do seu ecossistema.

2. Erro de porta já em uso

Causa: Outro processo já está escutando na mesma porta.
Solução: Identifique e interrompa o processo conflitante:
```
sudo lsof -i :3000

sudo kill -9 <PID>
```
Alternativamente, altere a porta do seu aplicativo no arquivo .env ou na configuração do ecossistema.

3. Nginx 502 Bad Gateway

Causa: O Nginx não consegue acessar o aplicativo Node.js, geralmente porque o aplicativo travou, parou ou está vinculado a uma porta diferente.
Solução: Reinicie o aplicativo Node.js e recarregue o Nginx:
```
pm2 restart all

sudo systemctl reload nginx
```
Certifique-se de que o valor do proxy_pass do Nginx corresponda ao endereço de escuta da sua aplicação Node.js (por exemplo, http://localhost:3000).

4. Erros de permissão negada

Causa: O usuário do aplicativo não possui permissão para ler ou escrever em determinados arquivos ou diretórios.
Solução: Defina a propriedade e as permissões corretas:
```
sudo chown -R $USER:$USER /var/www/myapp

sudo chmod -R 755 /var/www/myapp
```
Evite executar Node.js ou PM2 como usuário root.

5. Falha na renovação do Certbot

Causa: Problemas de DNS, certificados expirados ou configuração incorreta do Nginx.
Solução: Confirme se os registros DNS apontam para o seu servidor e teste a renovação:
```
sudo certbot renew --dry-run
```
Se a renovação falhar, revise a configuração do Nginx em busca de erros de sintaxe:
```
sudo nginx -t
```
Você também pode verificar os logs do Certbot em /var/log/letsencrypt/ para erros detalhados.

6. Firewall bloqueando o acesso

Causa: As regras do UFW impedem conexões HTTP ou HTTPS de entrada.
Solução: Certifique-se de que o tráfego do Nginx está permitido e que o firewall está ativo:
```
sudo ufw allow 'Nginx Full'

sudo ufw enable

sudo ufw status
```

Fluxo de Trabalho de Solução de Problemas

Quando surgirem problemas, siga um processo estruturado:

Verificar Logs: Revise primeiro os logs do PM2, Nginx e do sistema, pois a maioria dos problemas deixa rastros de erro aqui.
Verificar Serviços: Confirme se o Node.js, PM2 e o Nginx estão em execução e habilitados na inicialização:
```
pm2 status

systemctl status nginx
```
Validar Arquivos de Configuração: Execute verificações de sintaxe antes de reiniciar os serviços:
```
sudo nginx -t
```
Para arquivos do ecossistema PM2, verifique a formatação JSON ou JavaScript.
Verificar Vinculação de Porta: Verifique se seu aplicativo está ouvindo na porta esperada:
```
sudo netstat -tulnp | grep node
```
Monitorar Recursos do Sistema: Use ferramentas como htop ou pm2 monit para verificar o uso de CPU, memória e disco. Servidores sobrecarregados podem causar respostas lentas ou travamentos.
Testar Conectividade: Use curl para simular requisições e verificar se seus endpoints respondem corretamente:
```
curl http://localhost:3000
```

Melhores Práticas para Estabilidade, Segurança e Manutenção

Seguir as melhores práticas garante que sua aplicação permaneça confiável, segura e fácil de manter à medida que cresce.

Melhores Práticas de Segurança

Mantenha o sistema atualizado: Atualize regularmente o Node.js, PM2, Nginx e os pacotes do Ubuntu usando:
```
sudo apt update && sudo apt upgrade -y
```
Isso garante que os patches de segurança e as melhorias de desempenho sejam aplicados.
Use HTTPS em todos os lugares: Sempre force o HTTPS através de redirecionamentos no Nginx e renovação automática de certificados com o Certbot.
Restringir o acesso SSH: Use autenticação baseada em chave, desative logins de root e limite o SSH a IPs conhecidos.
Execute como um usuário não root: Use um usuário de aplicativo dedicado para limitar os privilégios em caso de comprometimento.
Ocultar rastreamentos de pilha e detalhes de erro: Nunca exponha mensagens de erro detalhadas aos usuários. Configure o Express ou outros frameworks para lidar com erros de forma adequada.
Audite regularmente as dependências: Execute:
```
npm audit
```
e atualizar ou substituir pacotes vulneráveis.

Desempenho e Gerenciamento de Recursos

Ativar clusterização: Use o PM2 para executar múltiplas instâncias do Node.js nos núcleos de CPU disponíveis:
```
pm2 start app.js -i max
```
Use o cache de forma eficaz: Implemente camadas de cache (como Redis ou cache em memória) para dados acessados com frequência.
Monitore regularmente: Configure painéis com PM2 Plus, Grafana ou Prometheus para acompanhar as tendências de desempenho.
Otimizar logs: Habilite a rotação de logs para evitar o uso excessivo do disco e mantenha apenas os dados relevantes.
Compactar respostas: Mantenha a compressão gzip ou Brotli ativada no Nginx para uma entrega mais rápida.

Manutenção e Operações

Automatize backups: Agende backups dos dados do seu aplicativo, arquivos de configuração e certificados SSL.
Use controle de versão: Armazene configurações e scripts em um repositório Git para acompanhar as alterações ao longo do tempo.
Documente seu ambiente: Mantenha uma documentação detalhada da sua configuração, portas, variáveis de ambiente e etapas de implantação.
Use ambientes de teste: Teste atualizações e alterações de configuração em um servidor de teste antes de aplicá-las na produção.
Tempo de atividade do monitor: Use ferramentas externas de monitoramento de tempo de atividade como UptimeRobot, Pingdom ou StatusCake para detectar interrupções rapidamente.
Plano de escalabilidade: À medida que o tráfego cresce, considere a escalabilidade horizontal com balanceadores de carga ou ferramentas de orquestração de contêineres como Docker e Kubernetes.
Agende auditorias regulares: Revise periodicamente as configurações de segurança, métricas de desempenho e consistência de configuração entre os ambientes.

Uma estratégia de manutenção proativa, combinada com monitoramento contínuo e estrita adesão aos princípios de segurança, ajuda a garantir que sua aplicação Node.js permaneça performática, confiável e resiliente em produção.

Perguntas Frequentes

1. Como faço para implantar um aplicativo Node.js em produção no Ubuntu?

Para implantar uma aplicação pronta para produção, siga este fluxo de trabalho padrão. Evite executar o aplicativo usando node index.js diretamente em uma sessão de terminal, pois ele será encerrado se a sessão for fechada.

Aqui está um fluxo de trabalho geral:

Atualizar Sistema: Execute sudo apt update && sudo apt upgrade.
Crie um usuário não root: Nunca execute seu aplicativo como root. Crie um usuário dedicado (por exemplo, deploy).
Instale o Node.js: Use as distribuições binárias do NodeSource para a versão LTS mais recente (não use a versão padrão do apt do Ubuntu, pois frequentemente está desatualizada).
```
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -

sudo apt-get install -y nodejs
```
Clonar & Instalar: Clone seu repositório contendo o aplicativo Node.js, entre no diretório e execute npm ci (instalação limpa) em vez de npm install para garantir versões exatas das dependências.
Variáveis de Ambiente: Crie um arquivo .env para segredos (strings do banco de dados, chaves de API).
Comece com um Gerenciador de Processos: Em vez de executar node index.js (que para quando você fecha o terminal), use o PM2 para colocar o app em segundo plano:
```
sudo npm install -g pm2

pm2 start app.js --name "my-production-app"
```
Garanta a Persistência na Inicialização: Instrua o servidor a reiniciar este aplicativo caso o servidor seja reiniciado:
- Gerar o Script de Inicialização: Primeiro, peça ao PM2 para gerar o comando de inicialização para o seu sistema operacional específico (Ubuntu usa systemd).
```
pm2 startup
```
- Execute o Comando Gerado: Copie e cole o comando que o PM2 gerar no seu terminal. Ele terá uma aparência semelhante a esta: sudo env PATH=` PATH:/home/sammy/.nvm/versions/node/v24.11.1/bin /home/sammy/.nvm/versions/node/v24.11.1/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy
- Congelar a Lista de Processos: Agora que o sistema de inicialização está ativo, salve seus processos em execução para que o PM2 os lembre na reinicialização.
```
pm2 save
```

2. Qual é a melhor maneira de gerenciar processos Node.js em um VPS?

O padrão da indústria para gerenciar processos Node.js em um Servidor Virtual Privado (VPS) é o PM2.

Embora você possa usar o systemd diretamente, o PM2 oferece recursos especificamente projetados para Node.js que os gerenciadores de serviço padrão não possuem, como:

Reinício Automático: Reinicia o aplicativo se ele travar.
Modo Cluster: Utiliza todos os núcleos da CPU sem alterar seu código.
Monitoramento: Comandos integrados para verificar o uso de RAM/CPU (pm2 monit).
Gerenciamento de Logs: Faz a rotação automática dos logs para evitar acúmulo no disco.

3. Devo usar PM2 ou `systemd` para Node.js em produção?

A melhor prática é usar os dois.

Você deve usar o PM2 para gerenciar a aplicação e o Systemd para gerenciar o PM2. Se você usar apenas o PM2, seu app desaparecerá se o servidor for reiniciado.

Como combiná-los:

Inicie seu app com PM2: pm2 start app.js
Gere o script de inicialização do systemd: pm2 startup
Execute o comando que o PM2 gera (isso instrui o systemd do Ubuntu a iniciar o PM2 na inicialização).
Congelar a lista de processos: pm2 save

4. Como eu uso o Nginx como um proxy reverso para Node.js?

Node.js é excelente em lidar com a lógica de aplicação, mas ruim em lidar com SSL, arquivos estáticos e balanceamento de carga em comparação com o Nginx.

A Configuração:

Instale o Nginx: sudo apt install nginx.
Configure o Nginx para escutar na Porta 80 e encaminhar o tráfego para seu aplicativo Node (geralmente rodando em localhost:3000).

Exemplo de Configuração (/etc/nginx/sites-available/default):

server {
    listen 80;
    server_name your_domain.com;

    location / {
        proxy_pass http://localhost:3000; # Forward to Node
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Após salvar, teste a configuração com sudo nginx -t e reinicie o Nginx.

5. Como habilito HTTPS para Node.js com Nginx?

Não manipule HTTPS dentro da lógica da sua aplicação Node.js. Deixe o Nginx cuidar da criptografia/descriptografia (SSL Termination).

O Método Mais Fácil (Certbot):

Instale o Certbot: sudo apt install certbot python3-certbot-nginx
Execute o gerador automático:
```
sudo certbot --nginx -d your_domain.com
```
O Certbot irá editar automaticamente seu arquivo de configuração do Nginx para habilitar o HTTPS e configurar uma tarefa cron para renovar o certificado automaticamente.

6. Como posso proteger meu aplicativo Node.js no Ubuntu?

A segurança requer uma abordagem em camadas.

Nível do Sistema Operacional:
- Firewall UFW: Ative o firewall e permita apenas as portas necessárias.
```
sudo ufw allow ssh

sudo ufw allow 'Nginx Full'

sudo ufw enable
```
- Fortalecimento do SSH: Desative o login por senha e use apenas chaves SSH.
Nível de Aplicação:
- Executar como não-root: Como mencionado na Q1, se um invasor comprometer um processo root, ele terá controle total sobre o servidor.
- Helmet.js: Instale este middleware (npm install helmet) em seu aplicativo para configurar automaticamente cabeçalhos HTTP seguros.
- Não exponha portas: Certifique-se de que seu aplicativo Node esteja vinculado ao localhost (127.0.0.1) para que não possa ser acessado diretamente da internet, forçando o tráfego a passar pelo Nginx.

Resumo

Você agora configurou um ambiente de produção completo para sua aplicação Node.js no Ubuntu. Com o Node.js rodando sob o PM2, o Nginx gerenciando o tráfego web, criptografia SSL do Let’s Encrypt e o UFW protegendo sua rede, seu servidor está estável, seguro e pronto para uso no mundo real. Ao adicionar cache, compressão e monitoramento adequado, você construiu um sistema que tem bom desempenho e é fácil de manter. Esta configuração oferece uma base sólida para expandir sua aplicação, seja escalando entre servidores, automatizando implantações ou adicionando ferramentas mais avançadas no futuro.

Para mais tutoriais sobre Node.js, confira os seguintes artigos:

Como Instalar o Node.js no Ubuntu (Guia Passo a Passo)
Como Usar PostgreSQL com Node.js no Ubuntu 20.04

Obrigado por aprender com a comunidade Linux-Console.net.

Como Configurar uma Aplicação Node.js para Produção no Ubuntu

Introdução

Pré-requisitos

Instalar e Verificar o Node.js

Instalar Node.js via PPA do NodeSource

Instale o npm e os pacotes build-essential

Criar um aplicativo de exemplo em Node.js

Crie um servidor Node.js simples

Testar o aplicativo

Por que os aplicativos devem se conectar ao localhost em produção

Instalar e Configurar o Gerenciador de Processos PM2

Instalando o PM2

Habilitando Reinício Automático em Caso de Falha e Reboot

Usando o arquivo de ecossistema do PM2

Comandos PM2 adicionais

Configurar o Nginx como um Proxy Reverso

Configuração Básica de Proxy Reverso

Adicionando Configuração HTTPS (SSL)

Roteamento de Múltiplas Aplicações (Opcional)

Configure o Firewall UFW para Produção

Verificando o status do firewall

Permitir Tráfego Essencial

Por Que um Firewall é Importante na Produção

Ativar SSL com Let’s Encrypt

Instale o Certbot e o plugin do Nginx

Obter Certificados SSL

Renovação Automática

Por Que o HTTPS é Importante

Gerencie Variáveis de Ambiente de Forma Segura

Usando arquivos .env com dotenv

Variáveis de Ambiente com PM2

Melhores Práticas para Gerenciar Segredos

Técnicas de Otimização da Produção

Ativar Compressão (gzip ou Brotli)

Usando gzip

Usando Brotli

Configurar Cache no Nginx

Melhores Práticas de Registro

Logs do PM2

Logs do Nginx

Gerenciamento de Recursos e Otimização do Node.js

Usar Agrupamento

Monitorar o Uso de Memória e CPU

Descarregar recursos estáticos para o Nginx

Configuração do Ambiente

Monitoramento e Métricas

Por Que o Monitoramento é Importante

Monitorando Aplicações Node.js com PM2

Monitoramento em Tempo Real

Monitoramento de Logs

Monitoramento Avançado (PM2 Plus)

Monitorando Nginx

Registros de Acesso e Erros

Ativar Página de Status do Nginx

Coletando Métricas de Aplicações em Node.js

Monitoramento em Nível de Sistema

Erros Comuns, Solução de Problemas e Melhores Práticas

Erros Comuns e Correções

1. Aplicativo não inicia com PM2

2. Erro de porta já em uso

3. Nginx 502 Bad Gateway

4. Erros de permissão negada

5. Falha na renovação do Certbot

6. Firewall bloqueando o acesso

Fluxo de Trabalho de Solução de Problemas

Melhores Práticas para Estabilidade, Segurança e Manutenção

Melhores Práticas de Segurança

Desempenho e Gerenciamento de Recursos

Manutenção e Operações

Perguntas Frequentes

1. Como faço para implantar um aplicativo Node.js em produção no Ubuntu?

2. Qual é a melhor maneira de gerenciar processos Node.js em um VPS?

3. Devo usar PM2 ou systemd para Node.js em produção?

4. Como eu uso o Nginx como um proxy reverso para Node.js?

5. Como habilito HTTPS para Node.js com Nginx?

6. Como posso proteger meu aplicativo Node.js no Ubuntu?

Resumo

Usando arquivos `.env` com `dotenv`

3. Devo usar PM2 ou `systemd` para Node.js em produção?