Instalar Strapi no Rocky Linux 9 com Nginx

Importante: adapte nomes de usuário, senhas e domínios (por exemplo, strapi.example.com) para o seu ambiente antes de executar os comandos.

Diagrama de implantação do Strapi com Nginx e PostgreSQL

Strapi é um sistema de gerenciamento de conteúdo (CMS) headless de código aberto, construído com JavaScript. Como outros CMS headless, o Strapi não fornece um front-end por padrão: ele expõe uma API que permite criar a interface com frameworks populares como React ou Next.js. Com um sistema de plugins, o Strapi é flexível — o painel administrativo e a API são extensíveis, e quase todas as partes são customizáveis para diferentes casos de uso. O Strapi também inclui um sistema de usuários para controlar detalhadamente o acesso de administradores e usuários finais.

Neste tutorial você aprenderá a instalar a versão comunitária do Strapi em um servidor Rocky Linux 9 junto com Nginx atuando como proxy reverso.

O que você vai precisar

Um servidor com Rocky Linux 9 e pelo menos 2 GB de RAM e 1 vCPU.
Um usuário não-root com privilégios sudo.
Um nome de domínio totalmente qualificado (FQDN), por exemplo strapi.example.com.
Sistema atualizado e alguns pacotes básicos.

Execute (como usuário com sudo):

$ sudo dnf update

Instale utilitários necessários (alguns já podem estar presentes):

$ sudo dnf install wget curl nano unzip yum-utils -y

Passo 1 - Configurar firewall

Rocky Linux usa firewalld. Verifique o status:

$ sudo firewall-cmd --state
running

O firewall organiza regras por zonas; usaremos a zona public por padrão. Liste serviços ativos:

$ sudo firewall-cmd --permanent --list-services

Provavelmente verá algo como:

cockpit dhcpv6-client ssh

Abra as portas HTTP e HTTPS para o Strapi ser acessível por Nginx:

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Recarregue o firewall para aplicar mudanças:

$ sudo firewall-cmd --reload

Confirme novamente:

$ sudo firewall-cmd --permanent --list-services

Você deverá ver:

cockpit dhcpv6-client http https ssh

Passo 2 - Instalar e configurar PostgreSQL

Strapi funciona com PostgreSQL 11+. Rocky Linux 9 traz PostgreSQL 13 por padrão; neste guia usamos PostgreSQL 15.

Adicione a chave GPG do repositório PostgreSQL:

$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null

Instale o pacote do repositório do PostgreSQL:

$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm

Desative o módulo postgresql embutido:

$ sudo dnf -qy module disable postgresql

Instale o servidor PostgreSQL 15:

$ sudo dnf install -y postgresql15-server

Inicialize a base de dados:

$ sudo /usr/pgsql-15/bin/postgresql-15-setup initdb

Habilite e inicie o serviço PostgreSQL:

$ sudo systemctl enable postgresql-15
$ sudo systemctl start postgresql-15

Verifique o status (exemplo de saída):

$ sudo systemctl status postgresql-15
? postgresql-15.service - PostgreSQL 15 database server
     Loaded: loaded (/usr/lib/systemd/system/postgresql-15.service; enabled; vendor preset: disabled)
     Active: active (running) since Wed 2023-02-01 13:21:27 UTC; 41min ago
       Docs: https://www.postgresql.org/docs/15/static/
    Process: 53088 ExecStartPre=/usr/pgsql-15/bin/postgresql-15-check-db-dir ${PGDATA} (code=exited, status=0/SUCCESS)
   Main PID: 53093 (postmaster)
      Tasks: 7 (limit: 5727)
     Memory: 45.7M
        CPU: 1.112s
     CGroup: /system.slice/postgresql-15.service
             ??53093 /usr/pgsql-15/bin/postmaster -D /var/lib/pgsql/15/data/
             ??53094 "postgres: logger "
             ??53095 "postgres: checkpointer "
             ??53096 "postgres: background writer "
             ??53098 "postgres: walwriter "
             ??53099 "postgres: autovacuum launcher "
             ??53100 "postgres: logical replication launcher "

Acesse o shell do PostgreSQL como usuário postgres:

$ sudo -i -u postgres psql

Crie o banco de dados e o usuário do Strapi (substitua ‘Your_Password’ por uma senha forte):

postgres=# CREATE DATABASE strapidb;
postgres-# CREATE USER strapiuser WITH PASSWORD 'Your_Password';
postgres-# ALTER DATABASE strapidb OWNER TO strapiuser;
postgres-# \q

Verifique as credenciais:

$ psql --username strapiuser --password --host localhost strapidb
Password:
psql (15.1)
Type "help" for help.

strapidb=>

Digite \q para sair.

Passo 3 - Instalar Node.js

Rocky Linux 9 pode trazer Node v16; instale a versão LTS mais recente suportada pelo Strapi (v18 no momento deste guia).

Adicione o instalador oficial do NodeSource para Node 18:

$ curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash -

Instale o Node.js:

$ sudo dnf install nodejs -y

Verifique a versão:

$ node -v
v18.13.0

Passo 4 - Instalar Strapi

Crie o projeto Strapi com o utilitário oficial:

$ npx create-strapi-app@latest howtoforge-project
Need to install the following packages:
  [email protected]
Ok to proceed? (y) y

Responda às perguntas do instalador. Escolha Custom e preencha conforme abaixo:

? Choose your installation type Custom (manual settings)
? Choose your preferred language JavaScript
? Choose your default database client postgres
? Database name: strapidb
? Host: 127.0.0.1
? Port: 5432
? Username: strapiuser
? Password: Your_Password
? Enable SSL connection: No

Você pode optar por JavaScript ou TypeScript conforme preferir.

Entre na pasta do projeto:

$ cd howtoforge-project

Construa o projeto (inclui painel administrativo):

$ NODE_ENV=production npm run build

Inicie o servidor Strapi manualmente (apenas para teste):

$ node ~/howtoforge-project/node_modules/.bin/strapi start

Por padrão o Strapi escuta em http://:1337. Antes de acessar, abra a porta no firewall:

$ sudo firewall-cmd --permanent --add-port=1337/tcp
$ sudo firewall-cmd --reload

Ao acessar a URL verá a página inicial do Strapi em ambiente de desenvolvimento.

Tela inicial do Strapi em desenvolvimento

Pare o servidor com Ctrl + C no terminal. Em seguida remova a regra temporária do firewall (não é necessária em produção quando Nginx faz o proxy):

$ sudo firewall-cmd --permanent --remove-port=1337/tcp
$ sudo firewall-cmd --reload

Passo 5 - Instalar e configurar PM2

Para rodar Strapi em produção use um gerenciador de processos como o PM2 (Process Manager 2). Ele cria um serviço systemd e reinicia o app em caso de falha.

Troque para o diretório home do seu usuário (substitua ‘navjot’ pelo seu usuário, se aplicável):

$ cd ~

Instale o PM2 globalmente:

$ sudo npm install pm2@latest -g

Crie o arquivo de configuração do PM2:

$ sudo nano ecosystem.config.js

Cole o conteúdo abaixo, ajustando cwd e credenciais do banco conforme seu projeto:

module.exports = {
  apps: [
    {
      name: 'strapi',
      cwd: '/home/navjot/howtoforge-project',
      script: 'npm',
      args: 'start',
      env: {
        NODE_ENV: 'production',
        DATABASE_HOST: 'localhost',
        DATABASE_PORT: '5432',
        DATABASE_NAME: 'strapidb',
        DATABASE_USERNAME: 'strapiuser',
        DATABASE_PASSWORD: 'Your_Password',
      },
    },
  ],
};

Salve e saia (Ctrl + X, Y).

Inicie a aplicação com PM2:

$ pm2 start ecosystem.config.js

A saída do PM2 mostra o daemon sendo criado e a aplicação lançada. Para tornar o PM2 persistente no boot, gere o script systemd (o comando exato é mostrado na saída de pm2 startup):

$ pm2 startup

Copie e execute o comando sugerido (exemplo abaixo). Ajuste usuário e caminho se necessário:

$ sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u navjot --hp /home/navjot

Salve a lista de processos para restaurar no boot:

$ pm2 save
[PM2] Saving current process list...
[PM2] Successfully saved in /home/navjot/.pm2/dump.pm2

Agora o Strapi está rodando em segundo plano no modo produção.

Passo 6 - Instalar Nginx

Instale a versão oficial mais recente do Nginx adicionando o repositório oficial.

Crie o arquivo /etc/yum.repos.d/nginx.repo:

$ sudo nano /etc/yum.repos.d/nginx.repo

Cole:

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Salve e instale o Nginx:

$ sudo dnf install -y nginx

Verifique a versão instalada:

$ nginx -v
nginx version: nginx/1.22.1

Habilite e inicie o serviço:

$ sudo systemctl enable nginx --now

Verifique o status:

$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
     Active: active (running) since Wed 2023-02-01 15:01:29 UTC; 7s ago
       Docs: http://nginx.org/en/docs/
    Process: 4637 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 4638 (nginx)
      Tasks: 2 (limit: 10884)
     Memory: 1.9M
        CPU: 8ms
     CGroup: /system.slice/nginx.service
             ??4638 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??4639 "nginx: worker process"

Passo 7 - Instalar SSL (Certbot)

Para HTTPS, use Certbot (Let’s Encrypt). Em Rocky Linux, o método confiável é instalar via snapd.

Instale EPEL e o snapd:

$ sudo dnf install -y epel-release
$ sudo dnf install -y snapd
$ sudo systemctl enable snapd --now
$ sudo snap install core && sudo snap refresh core

Crie o link necessário para o snap funcionar corretamente e adicione ao PATH:

$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh

Instale o Certbot e crie um atalho:

$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Verifique versão:

$ certbot --version
certbot 2.2.0

Gere o certificado (substitua e-mail e domínio):

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d strapi.example.com

O certificado será salvo em /etc/letsencrypt/live/strapi.example.com.

Gere parâmetros Diffie–Hellman para maior segurança TLS (pode demorar):

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Teste a renovação automática com um dry run:

$ sudo certbot renew --dry-run

Se não houver erros, a renovação automática estará configurada.

Passo 8 - Configurar Nginx como proxy reverso

Edite o arquivo principal do Nginx e aumente server_names_hash_bucket_size antes de incluir arquivos de configuração:

$ sudo nano /etc/nginx/nginx.conf

Adicione antes de include /etc/nginx/conf.d/*.conf;:

server_names_hash_bucket_size  64;

Crie o arquivo de site para o Strapi:

$ sudo nano /etc/nginx/conf.d/strapi.conf

Cole a configuração abaixo (substitua o server_name pelo seu domínio):

server {
  # Redirect any http requests to https
  listen         80;
  listen         [::]:80;
  server_name    strapi.example.com;
  return 301     https://$host$request_uri;
}

server {
  listen                    443 ssl http2;
  listen                    [::]:443 ssl http2;
  server_name               strapi.example.com;

  access_log                /var/log/nginx/strapi.access.log;
  error_log                 /var/log/nginx/strapi.error.log;

  # TLS configuration
  ssl_certificate           /etc/letsencrypt/live/strapi.example.com/fullchain.pem;
  ssl_certificate_key       /etc/letsencrypt/live/strapi.example.com/privkey.pem;
  ssl_trusted_certificate   /etc/letsencrypt/live/strapi.example.com/chain.pem;
  ssl_protocols             TLSv1.2 TLSv1.3;

  ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
  ssl_prefer_server_ciphers on;
  ssl_session_cache         shared:SSL:50m;
  ssl_session_timeout       1d;

  # OCSP Stapling ---
  # fetch OCSP records from URL in ssl_certificate and cache them
  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_dhparam /etc/ssl/certs/dhparam.pem;

  location / {
    proxy_set_header        X-Real-IP $remote_addr;
    proxy_set_header        X-Forwarded-Proto $scheme;
    proxy_set_header        X-Forwarded-Host $http_host;
    proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass              http://127.0.0.1:1337;
  }
}

Verifique a sintaxe do Nginx e reinicie:

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
$ sudo systemctl restart nginx

Acesse agora https://strapi.example.com. Em produção você verá que o Strapi está rodando no modo production.

Strapi rodando em produção

Para acessar o painel administrativo, visite:

https://strapi.example.com/admin

Página de criação de usuário admin do Strapi

Preencha os dados do administrador e clique em “Let’s start” para entrar no dashboard:

Painel administrativo do Strapi

A partir do painel, você pode criar conteúdo, coleções (content-types), integrar APIs e plugins.

Passo 9 - Atualizar o Strapi

Antes de atualizar, pare a instância gerenciada pelo PM2:

$ cd ~
$ pm2 stop ecosystem.config.js

Abra o package.json do projeto e atualize os números de versão dos pacotes Strapi para a versão estável mais recente (verifique o GitHub Releases do Strapi para a versão atual):

$ cd howtoforge-project
$ nano package.json

Exemplo de trechos a atualizar (substitua por versões atuais):

"devDependencies": {},
  "dependencies": {
    "@strapi/strapi": "4.5.5",
    "@strapi/plugin-users-permissions": "4.5.5",
    "@strapi/plugin-i18n": "4.5.5",
    "pg": "8.6.0"
  },

Depois de ajustar as versões, instale dependências e reconstrua o painel:

$ npm install
$ NODE_ENV=production npm run build

Reinicie com PM2:

$ cd ~
$ pm2 start ecosystem.config.js

Seu Strapi estará atualizado e em execução.

Diagnóstico rápido e resolução de problemas

Se o painel admin não carregar: verifique os logs do PM2 (pm2 logs strapi) e do Nginx (/var/log/nginx/strapi.error.log).
Erro de conexão ao banco: confirme host, porta, nome do BD, usuário e senha no ecosystem.config.js e teste com psql local.
Erro TLS/SSL: verifique caminhos em ssl_certificate e se os certificados realmente existem em /etc/letsencrypt/live/.
Porta 1337 não acessível: confirme que o PM2 está executando e que o Strapi está escutando em 127.0.0.1:1337.

Checklists por função

Administrador do Sistema (Sysadmin):
- Verificar atualizações do sistema e dependências.
- Habilitar e testar backups do banco e arquivos /etc/letsencrypt.
- Configurar monitoramento (ex.: Prometheus / Grafana ou alertas do PM2).
DBA:
- Gerenciar rotinas de backup e restauração do PostgreSQL.
- Garantir que usuários do BD tenham permissões mínimas necessárias.
- Monitorar autovacuum e espaço em disco.
Desenvolvedor:
- Usar variáveis de ambiente para segredos (não commit em VCS).
- Testar migrações de conteúdo em ambientes de staging antes de production.
- Versionar schemas e plugins customizados.
Segurança/DevSecOps:
- Restringir acesso ao PostgreSQL por firewall (permitir só localhost ou rede privada).
- Desativar exposições desnecessárias (evitar expor 1337 na internet).
- Habilitar cabeçalhos de segurança no Nginx conforme necessidade (HSTS, X-Frame-Options).

Mini-metodologia de deploy seguro

Provisionar servidor e DNS para o domínio.
Atualizar sistema e instalar dependências (Node, PostgreSQL, Nginx, snapd).
Criar banco e usuário PostgreSQL com senha forte.
Criar projeto Strapi em ambiente de staging e testar.
Configurar PM2 e validar que o processo ressurge após falhas.
Configurar Nginx com TLS (Certbot) e testar renovação.
Habilitar backups e monitoramento antes de mover para produção.

Regras de segurança e endurecimento (hardening)

Nunca exponha diretamente a porta 1337 ao público; use o Nginx como proxy reverso.
Armazene senhas e segredos em cofre (Vault) ou variáveis de ambiente do sistema, não em arquivos versionados.
Atualize regularmente o Node.js, Strapi e dependências; teste em staging.
Configure limitações de recursos (systemd, ulimits) e monitore memória/CPU.
Use TLS moderno: TLSv1.2+ e preferir 1.3; gere dhparam 4096 conforme mostrado.

Edge cases e quando esse guia pode falhar

Sistemas com menos de 2 GB de RAM podem apresentar falhas de build ao executar npm run build em produção.
Ambientes corporativos com proxies outbound restritos podem bloquear o download de pacotes; ajuste proxies de sistema.
Se o domínio não aponta para o servidor, Certbot falhará na validação HTTP/HTTPS.

Dicas de migração e atualização

Antes de atualizar Strapi, exporte dados e faça snapshot do banco de dados.
Teste atualizações em um ambiente de staging idêntico ao production.
Consulte notas de versão do Strapi para mudanças de breaking changes e execute migrações necessárias.

Galeria de testes e critérios de aceitação

Instalação: Strapi inicia sem erros em modo production via PM2.
Proxy: https://seu-dominio/admin abre o painel administrativo com certificado válido.
Banco: Conexão com PostgreSQL bem-sucedida e CRUD básico via API.
Persistência: PM2 restaura processos após reinicialização do servidor.

Glossário (1 linha cada)

CMS headless: CMS que expõe conteúdo via API, sem front-end integrado.
PM2: Gerenciador de processos para aplicações Node.js com suporte a systemd.
Certbot: Cliente automatizado para obter certificados Let’s Encrypt.
Nginx: Servidor web e proxy reverso de alto desempenho.

Fluxo de decisão rápido (Mermaid)

flowchart TD
  A[Precisa de CMS headless?] -->|Sim| B{Ambiente de produção pronto?}
  B -->|Não| C[Configurar servidor, DNS e firewall]
  B -->|Sim| D[Instalar Node, PostgreSQL]
  D --> E[Instalar Strapi e configurar PM2]
  E --> F[Configurar Nginx + Certbot]
  F --> G[Testar e monitorar]

Conclusão

Este tutorial cobriu a instalação completa do Strapi Community em Rocky Linux 9: preparação do servidor, configuração do PostgreSQL 15, instalação do Node.js 18, criação do projeto Strapi, execução em produção com PM2, configuração do Nginx como proxy reverso e emissão de certificados TLS com Certbot. Siga as checklists por função, faça backups regulares e teste atualizações em staging antes de aplicá-las em produção.

Observação final: personalize caminhos, nomes de usuário e senhas para o seu ambiente, automatize backups e integre monitoramento para garantir disponibilidade.

Resumo:

Instale e configure PostgreSQL 15, Node.js 18 e Strapi.
Rode Strapi em produção com PM2.
Use Nginx como proxy reverso e Certbot para SSL.
Adote boas práticas de segurança e backup.

Instalar Strapi no Rocky Linux 9 com Nginx como proxy reverso