Installare Strapi su Rocky Linux 9

Questa guida passo-passo mostra come installare e mettere in produzione Strapi (edizione community) su Rocky Linux 9 usando PostgreSQL, PM2 e Nginx come reverse proxy con HTTPS (Certbot). Seguendo i comandi illustrati configurerai firewall, database, Node.js, processo di produzione e SSL.

Intento principale

Installare e mettere in produzione Strapi su server Rocky Linux 9.

Varianti correlate: installare Strapi su Linux, configurare Strapi con PostgreSQL, Strapi + Nginx + PM2, Strapi in produzione, certificato SSL per Strapi.

Panoramica Strapi CMS

Strapi è un Content Management System (CMS) headless open source sviluppato in JavaScript. Come altri headless CMS, Strapi non fornisce un frontend pronto: espone invece un’API che puoi consumare con framework moderni come React o Next.js. Grazie a un sistema di plugin l’amministrazione e l’API sono estendibili e altamente personalizzabili. Strapi include anche un sistema di gestione utenti per controllare permessi e ruoli.

Questa guida mostra come installare la versione community di Strapi su un server Rocky Linux 9, configurare PostgreSQL come database, avviare Strapi come servizio di produzione con PM2, e proteggere l’app con Nginx e Certbot per HTTPS.

Sommario della procedura

Verifiche preliminari e requisiti
Configurazione firewall
Installazione e configurazione PostgreSQL 15
Installazione Node.js (LTS)
Creazione progetto Strapi e build
Gestione processo con PM2 e systemd
Installazione Nginx e certificato Let’s Encrypt
Configurazione Nginx come reverse proxy
Aggiornamento e manutenzione
Checklist, hardening e rollback

Requisiti

Server Rocky Linux 9 con almeno 2 GB di RAM e 1 CPU core.
Un utente non-root con privilegi sudo.
Un dominio completamente qualificato (FQDN), ad es. strapi.example.com.
Sistema aggiornato:

$ sudo dnf update

Pacchetti base necessari:

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

Note: alcuni pacchetti potrebbero essere già presenti sul sistema.

Importante

Esegui queste operazioni su un server di prova prima di applicarle in produzione.
Usa password forti per l’utente del database e proteggi le chiavi/credential.

Configurare il firewall

Rocky Linux usa firewalld. Verifica lo stato del firewall:

$ sudo firewall-cmd --state
running

Elenca i servizi attivi nella zona pubblica (di default):

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

Esempio di output previsto:

cockpit dhcpv6-client ssh

Apri le porte HTTP e HTTPS:

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

Ricarica il firewall:

$ sudo firewall-cmd --reload

Verifica nuovamente i servizi:

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

Output previsto:

cockpit dhcpv6-client http https ssh

Note operative:

Evita di esporre direttamente la porta dell’app (1337) su Internet. Usa Nginx come reverse proxy e apri solo 80/443 sul firewall.

Installare e configurare PostgreSQL

Strapi funziona con PostgreSQL 11+. Rocky Linux 9 include PostgreSQL 13, qui usiamo PostgreSQL 15.

Aggiungi la chiave GPG di PostgreSQL:

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

Installa il repository ufficiale e disabilita il modulo incorporato:

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

Installa PostgreSQL 15, inizializza il database e abilita il servizio:

$ sudo dnf install -y postgresql15-server
$ sudo /usr/pgsql-15/bin/postgresql-15-setup initdb
$ sudo systemctl enable postgresql-15
$ sudo systemctl start postgresql-15
$ sudo systemctl status postgresql-15

Apri la shell di postgres e crea database e utente (sostituisci la password):

$ sudo -i -u postgres psql
postgres=# CREATE DATABASE strapidb;
postgres-# CREATE USER strapiuser WITH PASSWORD 'Your_Password';
postgres-# ALTER DATABASE strapidb OWNER TO strapiuser;
postgres-# \q

Verifica la connessione:

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

strapidb=>

Suggerimenti:

Considera di creare lo user PostgreSQL con connessioni limitate e senza superuser.
Usa connessioni SSL tra Strapi e PostgreSQL se i servizi sono separati su host diversi.

Installare Node.js (LTS)

Rocky Linux 9 può avere Node v16; per compatibilità e supporto a lungo termine installa Node 18 LTS:

$ curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash -
$ sudo dnf install nodejs -y
$ node -v
v18.13.0

Nota: non usare versioni Node troppo nuove o non testate con la tua versione Strapi; verifica la compatibilità.

Creare e installare Strapi

Avvia l’installer ufficiale per creare il progetto Strapi:

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

Scegli Custom e rispondi come nell’esempio:

? 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

Dopo l’installazione:

$ cd howtoforge-project
$ NODE_ENV=production npm run build
$ node ~/howtoforge-project/node_modules/.bin/strapi start

A questo punto l’app è raggiungibile su http://:1337. Per motivi di sicurezza non esporre questa porta pubblicamente a lungo: la useremo temporaneamente per verificare prima di configurare Nginx.

Esempio: apri la porta in firewall temporaneamente (poi chiuderemo):

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

Dopo il controllo, interrompi Strapi (Ctrl+C) e rimuovi la regola firewall:

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

Schermata principale di Strapi in esecuzione

Gestire Strapi con PM2

Per gestire il processo in produzione usa PM2: crea un processo gestito e configura l’avvio automatico tramite systemd.

$ cd ~
$ sudo npm install pm2@latest -g
$ sudo nano ecosystem.config.js

Incolla e aggiorna il percorso e le credenziali Postgres:

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',
      },
    },
  ],
};

Avvia con PM2 e crea lo script di avvio:

$ pm2 start ecosystem.config.js
$ pm2 startup
# Copia e incolla il comando suggerito dall'output, ad es:
$ sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u navjot --hp /home/navjot
$ pm2 save

Verifica che il processo sia online: pm2 ls.

Vantaggi di PM2:

Riavvio automatico in caso di crash
Gestione log
Possibilità di scalare (cluster) se serve

Installare Nginx

Aggiungi il repository ufficiale Nginx per ottenere una versione aggiornata:

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

Incolla il contenuto del repository (come nell’esempio originale), poi:

$ sudo dnf install -y nginx
$ nginx -v
$ sudo systemctl enable nginx --now
$ sudo systemctl status nginx

Installare SSL con Certbot (via Snap)

Configura EPEL e Snapd, poi installa Certbot:

$ sudo dnf install -y epel-release
$ sudo dnf install -y snapd
$ sudo systemctl enable snapd --now
$ sudo snap install core && sudo snap refresh core
$ 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
$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
$ certbot --version
certbot 2.2.0

Richiedi il certificato (sostituisci email e dominio):

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

Questo genera i certificati in /etc/letsencrypt/live/strapi.example.com.

Genera un gruppo Diffie-Hellman:

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

Verifica il rinnovo automatico con una simulazione:

$ sudo certbot renew --dry-run

Configurare Nginx come reverse proxy per Strapi

Aggiungi questa impostazione globale in /etc/nginx/nginx.conf prima di include /etc/nginx/conf.d/*.conf;:

server_names_hash_bucket_size  64;

Crea il file di configurazione per Strapi:

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

Incolla il blocco seguente (aggiorna server_name e percorsi certificato se necessario):

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

Verifica la sintassi e riavvia Nginx:

$ sudo nginx -t
$ sudo systemctl restart nginx

Ora Strapi è raggiungibile via https://strapi.example.com. Per creare l’utente amministratore visita https://strapi.example.com/admin.

Pagina per creare utente amministratore Strapi

Dashboard amministratore Strapi

Aggiornare Strapi in produzione

Procedura di esempio per aggiornamento superficiale major/minor:

Ferma il processo PM2:

$ cd ~
$ pm2 stop ecosystem.config.js

Apri package.json nella directory del progetto e aggiorna le versioni dei pacchetti Strapi alle versioni stabili desiderate.

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

Esegui l’installazione e ricostruisci l’admin:

$ npm install
$ NODE_ENV=production npm run build

Riavvia con PM2:

$ cd ~
$ pm2 start ecosystem.config.js

Consigli:

Leggi sempre le note di rilascio ufficiali di Strapi per breaking changes.
Testa l’aggiornamento in staging prima di applicarlo in produzione.

Checklist per ruoli (ruoli e responsabilità)

Admin di sistema (Sysadmin): installazione OS, firewall, repository, backup del server.
DBA: installazione/configurazione PostgreSQL, backup/restore DB, tuning delle connessioni.
Developer: creazione progetti Strapi, migration dei contenuti, testing plugin.
DevOps: CI/CD, gestione PM2/systemd, monitoraggio e alerting.

Esempio di checklist minima prima del go-live:

Dominio DNS puntato verso il server.
Certificato HTTPS valido e rinnovabile automaticamente.
Servizio PostgreSQL sicuro e con backup schedulato.
PM2/systemd configurati e testati su reboot.
Log rotation configurata (/var/log/nginx, PM2 logs).

Sicurezza e hardening

Non esporre la porta 1337 direttamente su Internet. Usa Nginx come proxy.
Imposta limiti di connessione e rate-limiting su Nginx se serve.
Usa firewall per consentire solo 80/443.
Esegui Strapi con un utente non-root e limita permessi filesystem.
Aggiorna Node, Strapi e dipendenze regolarmente.
Proteggi credenziali con un secret manager (HashiCorp Vault, AWS Secrets Manager) se disponibili.
Disabilita endpoint non necessari e configura i permessi dei ruoli in Strapi.

Backup, ripristino e rollback (playbook rapido)

Backup DB (esempio cronologico):

$ sudo -u postgres pg_dump strapidb -Fc -f /backups/strapidb-$(date +%F).dump

Ripristino:

$ sudo -u postgres pg_restore -d strapidb /backups/strapidb-YYYY-MM-DD.dump

Rollback applicazione:

Ripristina package.json e package-lock.json alla versione precedente.
Esegui npm ci per reinstallare esattamente le dipendenze.
Ricostruisci (NODE_ENV=production npm run build) e riavvia PM2.

Incident runbook rapido:

Se l’app non risponde: controlla PM2 (pm2 ls, pm2 logs).
Controlla Nginx (sudo systemctl status nginx, sudo tail -n 200 /var/log/nginx/strapi.error.log).
Verifica uso CPU/RAM e spazio disco.
Se il DB non risponde: controlla systemctl status postgresql-15 e log PostgreSQL.
Se necessario, fallo ripartire in modalità manutenzione (impostare Nginx per mostrare una pagina 503 temporanea).

Esempi di errori comuni e come risolverli

Errore 502 Bad Gateway: probabilmente Nginx non raggiunge Strapi (processo non avviato o porta errata). Controlla pm2 ls e pm2 logs e verifica proxy_pass verso 127.0.0.1:1337.
Timeout di connessione DB: verifica credenziali in ecosystem.config.js e che PostgreSQL accetti connessioni su localhost.
Build admin fallisce: verifica la versione Node compatibile con la versione Strapi e aggiorna dipendenze.

Alternative e approcci diversi

Docker / Docker Compose: consente isolamento e utilizzo di immagini ufficiali Strapi + Postgres. Ideale per ambiente containerizzato e CI/CD.
Utilizzare SQLite in fase di sviluppo: più semplice ma non raccomandato in produzione su più istanze.
Piattaforme PaaS (DigitalOcean App Platform, Render, Heroku): semplificano deploy e certificati ma possono avere limiti su storage/file system.

Esempio rapido Docker Compose (schema):

version: '3'
services:
  strapi:
    image: strapi/strapi
    environment:
      DATABASE_CLIENT: postgres
      DATABASE_NAME: strapidb
      DATABASE_HOST: db
      DATABASE_PORT: 5432
      DATABASE_USERNAME: strapiuser
      DATABASE_PASSWORD: Your_Password
    ports:
      - '1337:1337'
    depends_on:
      - db
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: strapidb
      POSTGRES_USER: strapiuser
      POSTGRES_PASSWORD: Your_Password
    volumes:
      - db_data:/var/lib/postgresql/data
volumes:
  db_data:

Casi di test e criteri di accettazione

Installazione base: Strapi risponde su 127.0.0.1:1337 e pagina admin disponibile.
Produzione: accesso all’admin via HTTPS su https://strapi.example.com/admin.
Persistenza dati: creare una entry content-type e verificare che resti dopo riavvio del container/servizio.
Rinnovo SSL: certbot renew --dry-run deve completare senza errori.

Glossario (una riga ciascuno)

CMS: sistema per gestire contenuti.
Headless: CMS che espone contenuti via API, senza frontend integrato.
PM2: manager di processi Node.js per la produzione.
Nginx: server web/reverse proxy ad alte prestazioni.
Certbot: client per ottenere certificati Let’s Encrypt.

Note sulla privacy e GDPR

Se Strapi memorizza dati personali degli utenti, assicurati di:

Documentare la finalità del trattamento e il periodo di conservazione.
Configurare accessi e permessi minimi per gli operatori.
Offrire meccanismi per richiesta di accesso/cancellazione dati se richiesto dalla legge.

Migrazione e compatibilità

Prima di aggiornare Strapi major, leggi le note ufficiali: alcune API e plugin potrebbero richiedere migrazioni manuali.
Esegui backup del DB e del filesystem (file uploads) prima di ogni migrazione.

Conclusione

Questa guida completa ti porta dall’installazione di base alla messa in produzione sicura di Strapi su Rocky Linux 9 usando PostgreSQL, PM2 e Nginx con HTTPS. Segui le checklist e i playbook per testare e mantenere il sistema in produzione. In caso di dubbi, testa le modifiche in un ambiente di staging prima di applicarle in produzione.

Note finali:

Mantieni aggiornati OS, Node e Strapi.
Automatizza backup e monitoraggio.

Installare Strapi su Rocky Linux 9 con Nginx e PostgreSQL