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 a tornar pronta para produção, é necessário configurá-la para condições do mundo real que exigem estabilidade, segurança e desempenho. Um ambiente de produção corretamente configurado garante que a sua aplicação possa recuperar-se de falhas, servir tráfego de forma segura e lidar com um aumento da procura sem tempo de inatividade.

Neste guia, você irá construir uma configuração de produção completa no Ubuntu utilizando Node.js, PM2, Nginx, Let’s Encrypt e UFW. O Node.js executa a aplicação, o PM2 gere os processos e reinicia-os automaticamente, o Nginx trata os pedidos recebidos 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. Em conjunto, estas ferramentas formam uma base sólida para implementar aplicações fiáveis, eficientes e seguras.

Pré-requisitos

Este guia pressupõe que você tem o seguinte:

• Uma configuração de servidor Ubuntu, conforme descrito na configuração inicial do servidor com Ubuntu. Deverá ter um utilizador não root com privilégios sudo e um firewall ativo.
• Um nome de domínio apontado para o IP público do seu servidor. Este tutorial irá usar o nome de domínio example.com ao longo do texto.
• Nginx instalado, conforme explicado no guia Como Instalar e Configurar o Nginx no Ubuntu.
• Nginx configurado com SSL utilizando certificados Let’s Encrypt. Como garantir a segurança do Nginx com Let’s Encrypt no Ubuntu irá guiar-te através do processo.

Quando tiver concluído os pré-requisitos, terá um servidor a servir a página de marcador de posição por defeito do seu domínio em https://example.com/.

Instalar e Verificar o Node.js

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

Instalar o Node.js via PPA do NodeSource

Primeiro, instale o PPA do NodeSource para aceder ao seu repositório. Certifique-se de que está no seu diretório pessoal e use curl para descarregar 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

Pode rever o conteúdo do script com nano antes de o executar:

nano nodesource_setup.sh

Quando estiver pronto, execute o script com sudo:

sudo bash nodesource_setup.sh

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

Agora, 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

Deverá ver uma saída semelhante a esta:

v24.11.1

Instalar npm e build-essential

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

npm -v

Deverá ver uma saída semelhante:

11.6.2

Para que alguns pacotes npm funcionem (aqueles que requerem compilar código a partir da origem, por exemplo), será necessário instalar o pacote build-essential:

sudo apt install build-essential

Com o Node.js e o npm instalados com sucesso, já possui as ferramentas necessárias para desenvolver e gerir as dependências da sua aplicação. Na secção seguinte, irá criar uma aplicação Node.js simples para testar o ambiente de execução.

Criar uma Aplicação de Exemplo em Node.js

Vamos escrever uma aplicação simples em Node.js que retorna “Hello World” a qualquer pedido HTTP. Esta aplicação de exemplo irá verificar se o Node.js está instalado corretamente e demonstrar como as aplicações devem ser configuradas para ouvir de forma segura em localhost em produção.

Criar um servidor Node.js simples

Crie um novo ficheiro chamado hello.js no seu diretório pessoal:

cd ~

nano hello.js

Adicione o seguinte código ao ficheiro:

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}/`);
});

Guarde e feche o ficheiro quando terminar.

Este script cria um servidor HTTP simples que escuta na porta 3000 e responde com Hello World! a quaisquer pedidos recebidos. Como está ligado a localhost, só aceitará ligações a partir da mesma máquina.

Testar a aplicação

Execute a sua aplicação usando Node.js:

node hello.js

Deverá ver uma saída semelhante a:

Server running at http://localhost:3000/

Numa outra sessão de terminal, teste a sua aplicação com curl:

curl http://localhost:3000

Deverá ver a seguinte saída:

Hello World!

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

Quando tiver a certeza de que está a funcionar, termine a aplicação pressionando CTRL+C no terminal original para parar o servidor.

Por que as aplicações devem ligar-se ao localhost em produção

Em ambientes de produção, as aplicações Node.js normalmente estão atrás de um proxy reverso como o Nginx. A aplicação Node.js escuta num endereço interno (como localhost:3000), e o Nginx gere o tráfego web que chega, a terminação TLS e o encaminhamento.

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

• Evita exposição externa: Apenas o Nginx pode aceder diretamente ao processo Node.js.
• Permite o descarregamento de HTTPS: O Nginx gere os certificados SSL e a encriptação, descarregando este trabalho do Node.js.
• Simplifica as regras do firewall: O firewall pode bloquear o acesso a todas as portas de aplicações internas, permitindo apenas HTTP/HTTPS.

Esta configuração garante que a sua aplicação Node.js esteja isolada, segura e apenas acessível através do proxy reverso Nginx.

Instalar e Configurar o Gestor de Processos PM2

Nesta secção, irá instalar o PM2, um gestor de processos de produção para aplicações Node.js. O PM2 permite-lhe manter as suas aplicações a correr continuamente, reiniciá-las automaticamente após falhas e configurá-las para iniciar com o arranque do sistema.

A instalar o PM2

Use o npm para instalar o PM2 globalmente:

sudo npm install -g pm2

A flag -g instala o PM2 a nível do sistema, tornando-o disponível para todos os utilizadores e aplicações.

Uma vez instalado, inicie a sua aplicação de exemplo usando o PM2:

pm2 start hello.js

Verá uma tabela de saída que mostra que o PM2 começou a gerir a sua aplicação:

[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 da aplicação (com base no nome do ficheiro, sem a extensão .js) e um id do PM2. O PM2 também mantém outras informações, como o PID do processo, o seu estado atual e o uso de memória.

Ativar Reinício Automático em Caso de Falha e Reinício

O PM2 reinicia automaticamente a sua aplicação caso esta falhe ou seja terminada. Para garantir que o próprio PM2 arranca automaticamente quando o servidor reinicia, execute:

pm2 startup systemd

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

[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

Execute esse comando e depois guarde as aplicações em execução para que o PM2 se lembre delas na próxima reinicialização:

pm2 save

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

systemctl status pm2-sammy

Se encontrar problemas, reinicie o seu servidor e verifique se a sua aplicação inicia automaticamente.

Usando o Ficheiro de Ecossistema PM2

Quando estiver pronto para correr mais do que uma aplicação ou gerir diferentes ambientes, o ficheiro de ecossistema do PM2 é uma grande ajuda. É um ficheiro de configuração simples que permite definir variáveis de ambiente, portas e definições de deployment tudo num só lugar.

Gere um ficheiro inicial executando:

pm2 ecosystem

Em seguida, edite o ficheiro 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 a sua aplicação em modo de produção, utilize:

pm2 start ecosystem.config.js --env production

O ficheiro do ecossistema facilita a gestão de múltiplos ambientes e o armazenamento seguro de variáveis de ambiente fora do seu código-fonte. Com o PM2 instalado, a sua aplicação irá sobreviver a falhas, reinicializações e atualizações, tudo enquanto corre discretamente em segundo plano.

Comandos PM2 adicionais

Além daqueles que abordámos, o PM2 fornece muitos subcomandos que lhe permitem gerir ou consultar informações sobre as suas aplicações.

Pare uma aplicação com este comando (especifique o nome da App ou id no PM2):

pm2 stop app_name_or_id

Reiniciar uma aplicação:

pm2 restart app_name_or_id

Liste as aplicações atualmente geridas pelo PM2:

pm2 list

Obtenha informações sobre uma aplicação específica usando o seu Nome da aplicação:

pm2 info app_name

Para ver os registos em tempo real da sua aplicação:

pm2 logs

O monitor de processos PM2 pode ser aberto com o subcomando monit. Isto mostra o estado da aplicação, utilização da CPU e da memória:

pm2 monit

Note que executar pm2 sem quaisquer argumentos também exibirá uma página de ajuda com exemplos de utilização.

Agora que a sua aplicação Node.js está a correr e a ser gerida pelo PM2, vamos configurar o proxy reverso.

Configurar o Nginx como um Proxy Reverso

Com a sua aplicação Node.js a correr sob o PM2, o próximo passo é torná-la acessível aos utilizadores através da web. Em vez de expor a aplicação diretamente na porta 3000, vai usar o Nginx como proxy reverso. O Nginx irá gerir todos os pedidos HTTP e HTTPS recebidos e encaminhá-los para a sua aplicação Node.js a correr em localhost.

Configuração Básica de Reverse Proxy

Abra o ficheiro de configuração Nginx do seu site. Se seguiu a configuração da secção de pré-requisitos, este ficheiro deverá 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 o seu conteúdo pela seguinte configuração. Se a sua aplicação Node.js estiver a escutar numa porta diferente, atualize o valor destacado em conformidade.

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;
    }
...
}

Isto diz ao Nginx para ouvir na porta 80 (HTTP) e encaminhar todo o tráfego recebido para a sua aplicação Node.js a correr na porta 3000.

Para testar várias aplicações, pode definir blocos location adicionais. Por exemplo, se tiver outra aplicação Node.js a correr na porta 3001, adicione isto ao mesmo bloco do 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;
    }
...
}

Guarde o ficheiro e depois teste a configuração quanto a erros de sintaxe executando:

sudo nginx -t

Se tudo estiver correcto, recarregue o Nginx:

sudo systemctl reload nginx

Neste ponto, visitar o domínio do seu servidor (por exemplo, http://example.com) deverá carregar a aplicação Node.js a funcionar através do proxy Nginx.

Adicionar configuração HTTPS (SSL)

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

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 solicitações HTTP para HTTPS, e o segundo bloco trata o tráfego seguro na porta 443.

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

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

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

Cada aplicação pode ser gerida pelo seu próprio processo PM2 e servida através do Nginx.

Depois de confirmar que tudo está a funcionar, a sua aplicação Node.js deverá agora ser acessível de forma segura através do Nginx.

Configurar o Firewall UFW para Produção

Agora que a sua aplicação Node.js está a correr atrás do Nginx, vamos adicionar uma camada final de segurança de rede. O Ubuntu vem com um firewall incorporado chamado UFW (Uncomplicated Firewall). É leve, fácil de configurar e perfeito para bloquear acessos indesejados ao seu servidor.

Verificando o estado do firewall

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

sudo ufw status

Se indicar inativo, não se preocupe, iremos ativá-lo em breve. Mas primeiro, vamos definir quais tipos de tráfego devem ser permitidos. É sempre melhor configurar as regras antes de o ligar.

Permitir Tráfego Essencial

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

sudo ufw allow OpenSSH

sudo ufw allow 'Nginx Full'

Agora podemos ativar o firewall:

sudo ufw enable

Será solicitado que confirme: digite y e pressione Enter.

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

sudo ufw status

Deverias 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 só são permitidos o tráfego SSH e web; tudo o resto está bloqueado.

Por que um Firewall é Importante em Produção

Os firewalls são fundamentais para a segurança dos servidores porque estabelecem um controlo rigoroso sobre o tráfego de rede que pode alcançar o seu sistema. Mesmo aplicações e servidores web bem configurados podem ser vulneráveis se portas desnecessárias ficarem abertas.

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

• Minimizar a exposição: Apenas as portas explicitamente permitidas são acessíveis, reduzindo o número de vetores de ataque potenciais.
• Confinamento: No caso de uma violação ou configuração incorreta, um firewall limita o quão longe um atacante pode avançar 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: Os 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 controlo e ajuda a prevenir o acesso não autorizado à rede.

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

Ativar SSL com o Let’s Encrypt

Agora que a sua aplicação está publicamente acessível através do Nginx, é hora de adicionar HTTPS para comunicações seguras. O SSL encripta todo o tráfego entre o seu servidor e os utilizadores, garantindo privacidade e integridade dos dados. A forma mais fácil de adicionar SSL ao seu site é utilizando o Let’s Encrypt, uma autoridade certificadora gratuita e automatizada.

Instalar o Certbot e o Plugin do Nginx

O Let’s Encrypt funciona através de uma ferramenta chamada Certbot, que gere todo o processo de solicitação, instalação e renovação de certificados. No Ubuntu, pode instalar o Certbot juntamente com o seu plugin Nginx num único passo:

sudo apt update

sudo apt install certbot python3-certbot-nginx -y

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

Obter Certificados SSL

Uma vez que o Certbot esteja instalado, 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 o seu domínio aponta para este servidor (usando um desafio HTTP)
• Obtenha um certificado SSL da Let’s Encrypt
• Edite automaticamente a sua configuração Nginx para ativar o HTTPS
• Recarregar o Nginx para que as novas definições tenham efeito

Será solicitado um endereço de email (utilizado para notificações de renovação) e será pedido para concordar com os termos de serviço. Uma vez concluída a configuração, deverá ver uma mensagem de confirmação indicando que o seu certificado foi instalado com sucesso.

Pode verificar novamente os detalhes do seu certificado com:

sudo certbot certificates

Depois, visite o seu domínio para verificar se o site está agora a ser servido de forma segura.

Renovação Automática

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

Pode testar este processo de renovação a qualquer momento com:

sudo certbot renew --dry-run

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

Porque o HTTPS é importante

Executar a sua aplicação através de HTTPS deixou de ser opcional, é uma parte essencial de qualquer sistema em produção. O SSL/TLS garante que toda a comunicação entre o seu servidor e os clientes é encriptada e à prova de manipulação, protegendo contra escutas e manipulação de dados.

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

• Confiança e credibilidade: Os navegadores classificam os sites sem HTTPS como “Não Seguro”, o que pode prejudicar a confiança dos utilizadores.
• Melhoria no posicionamento nas pesquisas: Os principais motores de busca utilizam o HTTPS como um sinal de classificação.
• Acesso a funcionalidades web modernas: HTTP/2, QUIC e outras melhorias de desempenho requerem TLS.
• Conformidade: Muitos regulamentos de privacidade e normas da indústria exigem encriptação dos dados transmitidos.

Ao utilizar o Let’s Encrypt, obtém estes benefícios com configuração mínima e sem qualquer custo. Os certificados são renovados automaticamente, tornando-se uma solução fácil e duradoura para implementações seguras.

Com o HTTPS implementado, o seu servidor está agora a fornecer tráfego encriptado e confiável.

Gerir Variáveis de Ambiente de Forma Segura

Cada aplicação em produção precisa de uma forma fiável de gerir dados de configuração, como chaves de API, credenciais de base de dados ou tokens secretos. Armazenar estes valores diretamente no código-fonte pode expô-los através do controlo de versões, registos ou até fugas do lado do cliente. Uma abordagem mais segura é usar variáveis de ambiente, que mantêm a informação sensível separada da sua base de código.

Utilizar ficheiros .env com dotenv

Um método comum e simples para gerir variáveis de ambiente em Node.js é usar um ficheiro .env juntamente com o pacote dotenv. Esta configuração permite à sua aplicação ler 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

De seguida, crie um ficheiro .env no diretório do seu projeto:

nano .env

Adicione os 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 ficheiro principal da sua aplicação (por exemplo, app.js) para carregar as variáveis de ambiente ao iniciar:

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 a sua aplicação é executada, ela lê as variáveis definidas no ficheiro .env e usa-as para configurar o ambiente de execução.

Variáveis de Ambiente com PM2

Se estiver a executar a sua aplicação com PM2, pode definir variáveis de ambiente diretamente nos comandos ou ficheiros de configuração do PM2. Isto ajuda a manter as configurações consistentes em ambientes como desenvolvimento, teste e produção.

Pode definir variáveis diretamente ao iniciar uma aplicação:

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

Para uma solução mais limpa e escalável, utilize o ficheiro de configuração do ecossistema do PM2. Gere-o utilizando:

pm2 ecosystem

Em seguida, edite o ficheiro ecosystem.config.js para incluir as 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 a aplicação em modo de produção:

pm2 start ecosystem.config.js --env production

Isto garante que as variáveis corretas sejam carregadas automaticamente cada vez que a aplicação reinicia.

Melhores Práticas para Gerir Segredos

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

• Mantenha segredos fora do controlo de versões: Nunca faça commit de ficheiros .env no seu repositório Git. Adicione-os ao .gitignore para evitar a exposição acidental.

• Limitar o acesso: Apenas utilizadores de confiança e sistemas automatizados devem ter permissão para ler ou modificar ficheiros de configuração do ambiente.

• Utilize ficheiros específicos do ambiente: Mantenha configurações separadas para desenvolvimento, testes, pré-produção e produção. Por exemplo, .env.development e .env.production.

• Altere os segredos regularmente: Mude chaves de API, tokens e palavras-passe de forma programada para reduzir o impacto de possíveis fugas.

• Use um gestor de segredos para sistemas maiores: Para aplicações ou equipas complexas, considere utilizar serviços como o HashiCorp Vault em vez de ficheiros .env locais.

• Evite registar dados sensíveis: Tenha cuidado para não imprimir ou registar segredos nos logs da sua aplicação ou implementação.

• Validar variáveis de ambiente à inicialização: Utilize bibliotecas como joi ou env-schema para garantir que todas as variáveis necessárias estão definidas antes da execução da aplicação.

• Restringir permissões de ficheiros: Utilize o comando chmod para limitar o acesso aos ficheiros .env. Por exemplo:

  chmod 600 .env

Seguir estas 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 a sua aplicação a funcionar num ambiente de produção estável, é importante concentrar-se no desempenho e na eficiência. A otimização não só melhora a experiência do utilizador, como também reduz os custos do servidor e contribui para garantir uma escalabilidade fluida. Nesta secção, irá aprender várias técnicas para aperfeiçoar a configuração do Node.js e do Nginx, visando uma melhor velocidade, fiabilidade e utilização de recursos.

Ativar Compressão (gzip ou Brotli)

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

Usar gzip

Para ativar a compressão gzip, abra o ficheiro 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;

Estas definições ativam o gzip para tipos de ficheiro comuns, comprimem ficheiros com mais de 256 bytes e aplicam um nível de compressão moderado para equilibrar a carga do CPU e o desempenho.

A usar Brotli

Se tiver o módulo Brotli instalado, pode 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;

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

sudo systemctl reload nginx

Com a compressão ativada, os clientes irão descarregar os recursos mais rapidamente, resultando em tempos de carregamento mais rápidos e melhor desempenho tanto em computadores como em dispositivos móveis.

Configurar Cache no Nginx

O cache permite que o seu servidor reutilize respostas geradas anteriormente em vez de as regenerar para cada pedido. Isto reduz significativamente a carga na sua aplicação Node.js e acelera o tempo de resposta para os utilizadores finais.

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

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

Esta configuração instrui os navegadores a armazenarem em cache os recursos estáticos durante sete dias. Pode ajustar a duração dependendo de com que frequência os seus ficheiros estáticos mudam.

Para APIs ou conteúdos dinâmicos, o cache pode ser aplicado de forma mais seletiva. Por exemplo, pode armazenar em cache as respostas de endpoints frequentemente acedidos, enquanto exclui os endpoints que devolvem dados específicos do utilizador. O Nginx também suporta microcaching (cache de curta duração em segundos) para APIs com tráfego elevado.

Melhores Práticas de Registro

Os registos são essenciais para monitorização, resolução de problemas e optimização de desempenho. Tanto o PM2 como o Nginx oferecem ferramentas de registo abrangentes que ajudam a acompanhar o que se passa em todo o seu sistema.

Logs do PM2

O PM2 gere automaticamente os registos da sua aplicação. Para os ver em tempo real, use:

pm2 logs

Com o tempo, os registos podem crescer e ocupar espaço no 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

Esta configuração mantém os ficheiros de registo abaixo de 10 MB cada e conserva sete dias de registos. Pode ajustar estes valores com base na sua capacidade de armazenamento e nas necessidades de registo.

Registos do Nginx

O Nginx mantém tanto os registos de acesso (registos de cada pedido) como os registos de erro (informações sobre problemas e falhas). Estes registos são normalmente armazenados em /var/log/nginx/.

Pode rever os registos de acesso manualmente ou gerar um relatório detalhado de tráfego utilizando 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.

Registos bem geridos são essenciais para identificar gargalos de desempenho, pedidos falhados ou anomalias de segurança antes que afetem os utilizadores.

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

As aplicações Node.js executam-se numa única thread por defeito. Para utilizar todos os núcleos de CPU disponíveis e melhorar a concorrência, pode usar clustering e outras técnicas de gestão de processos.

Utilizar Agrupamento

O PM2 pode iniciar automaticamente múltiplos processos Node.js para tirar partido de CPUs com vários núcleos:

pm2 start app.js -i max

Este comando inicia tantas instâncias da sua aplicação quantos forem os núcleos de CPU do seu servidor. O PM2 irá gerir o balanceamento de carga e reiniciar os processos caso falhem.

Monitorizar a Memória e o Uso da CPU

Monitorize regularmente a utilização de recursos da sua aplicação para evitar fugas de memória ou consumo excessivo de CPU:

pm2 monit

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

Descarregar recursos estáticos para o Nginx

Deixe o Nginx servir ficheiros estáticos diretamente em vez de os encaminhar através do Node.js. Isto 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 definições de desempenho, como a verbosidade dos logs, limites de taxa da API ou duração do cache. Gerir a configuração através de variáveis de ambiente mantém a sua aplicação flexível e mais fácil de escalar.

Monitorização e Métricas

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

Vamos ver como pode monitorizar a sua aplicação Node.js, o servidor web Nginx e os recursos do sistema usando ferramentas integradas e serviços externos.

Por Que o Monitoramento é Importante

Em produção, cada segundo conta. Sem monitorização, problemas de desempenho ou interrupções de serviço podem passar despercebidos até afetarem os utilizadores. A monitorização ajuda-o a:

• Detete falhas rapidamente e receba alertas automáticos quando ocorrerem.
• Analisar o desempenho do sistema sob diferentes cargas de tráfego.
• Identificar pontos finais lentos, gargalos ou fugas de memória.
• Tome decisões informadas sobre dimensionamento e otimização.
• Mantenha a disponibilidade e a fiabilidade em todas as implementações.

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

Monitorização de Aplicações Node.js com PM2

PM2, o gestor de processos utilizado para executar a sua aplicação Node.js, inclui funcionalidades de monitorização poderosas.

Monitorização em Tempo Real

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

pm2 list

Isto mostra todas as aplicações activas juntamente com o seu estado, tempo de atividade, utilização de CPU e memória. Para uma visão mais detalhada e em tempo real, use:

pm2 monit

Isto abre um painel interativo que mostra métricas-chave de desempenho, como a utilização de CPU e memória por processo. Monitorizar estas métricas ajuda a detetar esgotamento de recursos, processos fora de controlo ou fugas de memória.

Monitorização de Logs

O PM2 também fornece gestão centralizada de logs. Para rever os logs da sua aplicação, execute:

pm2 logs

Pode visualizar os registos de uma aplicação específica usando:

pm2 logs myapp

Se notar reinícios frequentes, verifique a lista de processos do PM2 com:

pm2 status

Será mostrado quantas vezes cada processo reiniciou, o que pode ser um indicador de erros ou falhas.

Monitorização Avançada (PM2 Plus)

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

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

Monitorização do Nginx

O Nginx está na frente da sua stack de produção, gerindo pedidos HTTP e a terminação SSL. Monitorizar o Nginx é essencial para compreender como os utilizadores interagem com o seu sistema e quão eficientemente os pedidos estão a ser processados.

Registos de Acesso e Erros

O Nginx regista todos os pedidos que processa no ficheiro de registo de acessos, normalmente localizado em:

/var/log/nginx/access.log

Os erros são registados separadamente em:

/var/log/nginx/error.log

Pode rever estes registos em tempo real:

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

Os registos de acesso mostram informações valiosas, como os IPs dos clientes, tempos de resposta, códigos de estado e agentes de utilizador. Estes registos são úteis para identificar padrões como alta latência, erros 404 frequentes ou volumes de pedidos anormais.

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

Ativar a Página de Estado do Nginx

O Nginx inclui um módulo leve stub_status que expõe métricas do servidor em tempo real, como ligações atuais e contagem de pedidos. 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, pode ver as métricas visitando:

http://localhost/nginx_status

Estas métricas podem ser integradas em painéis de monitorização ou usadas para alertas automáticos.

Recolher Métricas de Aplicações a partir do Node.js

Para um monitorização a nível de aplicação mais detalhada, pode recolher métricas personalizadas diretamente da sua aplicação Node.js. Estas métricas podem acompanhar os tempos de resposta da API, as taxas de pedidos ou a duração das consultas à base 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');
});

Pode ligar este endpoint ao Prometheus ou ao Grafana para visualizar métricas como a latência das requisições, o uso de memória e o desempenho da recolha de lixo.

Monitorização ao Nível do Sistema

Além de monitorizar aplicações, mantenha também atenção ao desempenho geral do servidor. O Linux fornece várias ferramentas para este fim:

• htop ou top: Mostra a utilização de CPU e memória em tempo real.
• iostat: Monitoriza as operações de entrada/saída do disco.
• netstat ou ss: Mostra as ligações de rede abertas.
• vmstat: Acompanha processos, memória e estatísticas de I/O.

Pode automatizar a monitorização do sistema utilizando ferramentas como Netdata, Glances ou Grafana Agent, que recolhem 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 estruturada pode, ocasionalmente, enfrentar problemas. Compreender como identificar, diagnosticar e resolver essas questões é fundamental para manter a fiabilidade e reduzir ao mínimo o tempo de inatividade. Esta secção fornece passos detalhados de resolução de problemas para erros comuns e apresenta as melhores práticas para ajudá-lo a manter o seu ambiente Node.js estável, seguro e fácil de manter a longo prazo.

Erros Comuns e Soluções

1. A aplicação não consegue iniciar com o PM2

• Causa: Caminhos de ficheiro incorretos, dependências em falta ou variáveis de ambiente mal configuradas.

• Solução: Verifique os registos usando:

  pm2 logs

  Confirme se o caminho do ficheiro correto está a ser utilizado na sua configuração do PM2. Reinstale as dependências se necessário:

  npm install --production

  Verifique também se as variáveis de ambiente necessárias estão carregadas corretamente a partir do .env ou do seu ficheiro de ecossistema.

2. Erro de porta já em uso

• Causa: Outro processo já está a ouvir na mesma porta.

• Solução: Identifique e interrompa o processo em conflito:

  sudo lsof -i :3000
  
  sudo kill -9 <PID>

  Alternativamente, altere a porta da sua aplicação no ficheiro .env ou na configuração do ecossistema.

3. Nginx 502 Gateway Inválido

• Causa: O Nginx não consegue aceder à aplicação Node.js, geralmente porque a aplicação caiu, parou ou está associada a uma porta diferente.

• Solução: Reinicie a aplicação Node.js e recarregue o Nginx:

  pm2 restart all
  
  sudo systemctl reload nginx

  Certifique-se de que o valor proxy_pass do Nginx corresponde ao endereço onde a sua aplicação Node.js está a escutar (por exemplo, http://localhost:3000).

4. Erros de permissão negada

• Causa: O utilizador da aplicação não tem permissão para ler ou escrever em certos ficheiros 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 o Node.js ou o PM2 como utilizador 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 registos DNS apontam para o seu servidor e teste a renovação:

  sudo certbot renew --dry-run

  Se a renovação falhar, reveja a configuração do Nginx em busca de erros de sintaxe:

  sudo nginx -t

  Também pode verificar os registos do Certbot em /var/log/letsencrypt/ para obter erros detalhados.

6. Firewall a bloquear o acesso

• Causa: As regras do UFW impedem ligações HTTP ou HTTPS recebidas.

• 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 Resolução de Problemas

Quando surgirem problemas, siga um processo estruturado:

1. Verificar Registos: Revise primeiro os registos do PM2, Nginx e do sistema, pois a maioria dos problemas deixa aqui rastos de erro.

2. Verificar Serviços: Confirme que o Node.js, PM2 e o Nginx estão a funcionar e ativados no arranque:

   pm2 status
   
   systemctl status nginx

3. Validar Ficheiros de Configuração: Execute verificações de sintaxe antes de reiniciar os serviços:

   sudo nginx -t

   Para ficheiros do ecossistema PM2, verifique a formatação JSON ou JavaScript.

4. Verificar Ligação de Porta: Verifique se a sua aplicação está a escutar na porta esperada:

   sudo netstat -tulnp | grep node

5. Monitorizar os Recursos do Sistema: Utilize ferramentas como htop ou pm2 monit para verificar o uso de CPU, memória e disco. Servidores sobrecarregados podem causar respostas lentas ou falhas.

6. Testar Conectividade: Utilize curl para simular pedidos e verificar se os 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 a sua aplicação permaneça fiá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

  Isto garante que as correções de segurança e as melhorias de desempenho sejam aplicadas.

• Use HTTPS em todos os lugares: Faça sempre cumprir o HTTPS através de redirecionamentos Nginx e renovação automática de certificados com Certbot.

• Restringir o acesso SSH: Utilize autenticação baseada em chaves, desative os logins root e limite o SSH a IPs conhecidos.

• Executar como um utilizador não-root: Utilize um utilizador de aplicação dedicado para limitar privilégios em caso de comprometimento.

• Ocultar rastos de pilha e detalhes de erros: Nunca exponha mensagens de erro detalhadas aos utilizadores. 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.

Gestão de Desempenho e Recursos

• Ativar clusterização: Utilize 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 acedidos com frequência.

• Monitorize regularmente: Configure dashboards com PM2 Plus, Grafana ou Prometheus para acompanhar as tendências de desempenho.

• Otimizar registos: Ative a rotação de registos para evitar o uso excessivo do disco e manter 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

• Automatizar backups: Agende backups dos dados da sua aplicação, ficheiros de configuração e certificados SSL.
• Utilize controlo de versões: Armazene configurações e scripts num repositório Git para acompanhar as alterações ao longo do tempo.
• Documente o seu ambiente: Mantenha documentação detalhada da sua configuração, portas, variáveis de ambiente e passos de implementação.
• Use ambientes de teste: Teste atualizações e alterações de configuração num servidor de teste antes de as aplicar em produção.
• Tempo de atividade do monitor: Utilize ferramentas externas de monitorização de tempo de atividade como UptimeRobot, Pingdom ou StatusCake para detetar falhas rapidamente.
• Plano para escalabilidade: À medida que o tráfego aumenta, considere a escalabilidade horizontal com balanceadores de carga ou ferramentas de orquestração de containers como Docker e Kubernetes.
• Agende auditorias regulares: Reveja periodicamente as configurações de segurança, métricas de desempenho e consistência de configuração entre ambientes.

Uma estratégia de manutenção proativa, combinada com monitorização contínua e uma rigorosa adesão aos princípios de segurança, ajuda a garantir que a sua aplicação Node.js se mantenha performante, fiável e resiliente em produção.

Perguntas Frequentes

1. Como posso implementar uma aplicação Node.js em produção no Ubuntu?

Para implementar uma aplicação pronta para produção, siga este fluxo de trabalho standard. Evite executar a aplicação usando node index.js diretamente numa sessão de terminal, pois esta irá parar se a sessão for encerrada.

Aqui está um fluxo de trabalho geral:

1. Atualizar Sistema: Execute sudo apt update && sudo apt upgrade.

2. Criar um Utilizador Não Root: Nunca execute a sua aplicação como root. Crie um utilizador dedicado (por exemplo, deploy).

3. Instalar o Node.js: Utilize as distribuições binárias do NodeSource para a versão LTS mais recente (não utilize a versão apt padrão do Ubuntu, pois costuma estar desatualizada).

   curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
   
   sudo apt-get install -y nodejs

4. Clonar & Instalar: Clone o seu repositório contendo a aplicação Node.js, entre na diretoria e execute npm ci (instalação limpa) em vez de npm install para garantir versões exatas das dependências.

5. Variáveis de Ambiente: Crie um ficheiro .env para segredos (strings de BD, chaves de API).

6. Comece com um Gestor de Processos: Em vez de executar node index.js (que para quando fecha o terminal), use o PM2 para colocar a aplicação em segundo plano:

   sudo npm install -g pm2
   
   pm2 start app.js --name "my-production-app"

7. Assegurar Persistência na Inicialização: Instrua o servidor para reiniciar esta aplicação caso o servidor reinicie:

   • Gerar o Script de Arranque: Primeiro, peça ao PM2 para gerar o comando de arranque para o seu sistema operativo específico (o Ubuntu utiliza systemd).

   pm2 startup

   • Execute o Comando Gerado: Copie e cole o comando que o PM2 fornece no seu terminal. Irá parecer algo assim: 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 arranque está activo, salve os processos que estão a correr para que o PM2 os lembre na reinicialização.

   pm2 save

2. Qual é a melhor forma de gerir processos Node.js num VPS?

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

Embora possa usar o systemd diretamente, o PM2 oferece funcionalidades especificamente desenhadas para Node.js que os gestores de serviços padrão não têm, tais como:

• Reinício Automático: Reinicia a aplicação se esta falhar.
• Modo Cluster: Utiliza todos os núcleos da CPU sem alterar o seu código.
• Monitorização: Comandos integrados para verificar o uso de RAM/CPU (pm2 monit).
• Gestão de Logs: Roda automaticamente os logs para evitar sobrecarga do disco.

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

A melhor prática é usar ambos.

Deve usar o PM2 para gerir a aplicação e o Systemd para gerir o PM2. Se usar apenas o PM2, a sua aplicação desaparecerá se o servidor reiniciar.

Como combiná-los:

1. Inicie a sua aplicação com o PM2: pm2 start app.js
2. Gerar o script de arranque do systemd: pm2 startup
3. Execute o comando que o PM2 gera (isto diz ao systemd do Ubuntu para iniciar o PM2 no arranque).
4. Congelar a lista de processos: pm2 save

4. Como posso usar o Nginx como um proxy reverso para Node.js?

O Node.js é excelente a lidar com a lógica de aplicações, mas é fraco a lidar com SSL, ficheiros estáticos e balancing de carga comparado com o Nginx.

A Configuração:

1. Instalar o Nginx: sudo apt install nginx.
2. Configure o Nginx para escutar na Porta 80 e encaminhar o tráfego para a sua aplicação Node (normalmente a correr 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 guardar, teste a configuração com sudo nginx -t e reinicie o Nginx.

5. Como posso ativar HTTPS para Node.js com Nginx?

Não trate o HTTPS dentro da lógica da sua aplicação Node.js. Deixe o Nginx lidar com a encriptação/desencriptação (Terminação SSL).

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

1. Instalar o Certbot: sudo apt install certbot python3-certbot-nginx

2. Execute o gerador automático:

   sudo certbot --nginx -d your_domain.com

3. O Certbot irá editar automaticamente o seu ficheiro de configuração do Nginx para ativar o HTTPS e configurar um trabalho cron para renovar automaticamente o certificado.

6. Como posso proteger a minha aplicação Node.js no Ubuntu?

A segurança requer uma abordagem em camadas.

• Nível do Sistema Operativo:

  • 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 da Aplicação:

  • Executar como não-root: Como mencionado na Pergunta 1, se um atacante comprometer um processo root, ele terá o controlo do servidor.
  • Helmet.js: Instala este middleware (npm install helmet) na tua aplicação para definir automaticamente cabeçalhos HTTP seguros.
  • Não exponha portas: Certifique-se de que a sua aplicação Node está vinculada a localhost (127.0.0.1) para que não possa ser acedida diretamente pela internet, obrigando o tráfego a passar pelo Nginx.

Resumo

Agora configurou um ambiente de produção completo para a sua aplicação Node.js no Ubuntu. Com o Node.js a correr sob o PM2, o Nginx a gerir o tráfego web, encriptação SSL do Let’s Encrypt e o UFW a proteger a sua rede, o seu servidor está estável, seguro e pronto para uso real. Ao adicionar cache, compressão e monitorização adequada, construiu um sistema que tem bom desempenho e é fácil de manter. Esta configuração dá-lhe uma base sólida para expandir a sua aplicação, seja escalando entre servidores, automatizando implementações ou adicionando ferramentas mais avançadas no futuro.

Para mais tutoriais sobre Node.js, consulte 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.