Installer Strapi sur Rocky Linux 9

Ce guide explique étape par étape comment installer la version communautaire de Strapi sur un serveur Rocky Linux 9, en utilisant PostgreSQL, Node.js, PM2 pour la gestion des processus et Nginx comme reverse proxy avec TLS. Il couvre la configuration du pare-feu, la création de la base PostgreSQL, l’installation de Node.js et Strapi, la mise en service en production (PM2 + systemd), la configuration d’un certificat Let’s Encrypt et les bonnes pratiques de sécurité.

Important : adaptez les noms d’utilisateur, mots de passe, chemins et le nom de domaine (FQDN) à votre environnement avant d’exécuter les commandes.

Sommaire

Pré-requis
Étape 1 — Configuration du pare-feu
Étape 2 — Installation et configuration de PostgreSQL
Étape 3 — Installation de Node.js
Étape 4 — Installation de Strapi
Étape 5 — Gestion du processus avec PM2
Étape 6 — Installation de Nginx
Étape 7 — Installation du certificat SSL (Certbot)
Étape 8 — Configuration de Nginx comme reverse proxy
Étape 9 — Mise à jour de Strapi
Renforts opérationnels : checklists, runbook, sécurité, migration
Conclusion

Pré-requis

Un serveur Rocky Linux 9 avec au minimum 2 Go de RAM et 1 vCPU.
Un utilisateur non-root disposant de privilèges sudo.
Un nom de domaine pleinement qualifié (FQDN), par exemple strapi.example.com.
Système à jour :

$ sudo dnf update

Paquets utiles :

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

Certains paquets peuvent déjà être présents.

Étape 1 — Configuration du pare-feu

Rocky Linux utilise firewalld. Vérifiez l’état :

$ sudo firewall-cmd --state
running

Le zone par défaut est généralement public. Listez les services ouverts :

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

Vous devriez voir quelque chose comme cockpit dhcpv6-client ssh.

Strapi a besoin des ports HTTP et HTTPS. Ouvrez-les :

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

Rechargez la configuration :

$ sudo firewall-cmd --reload

Revérifiez :

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

Sortie attendue : cockpit dhcpv6-client http https ssh.

Note : pour l’installation initiale de Strapi vous ouvrirez temporairement le port 1337, puis vous le refermerez une fois Nginx en place.

Étape 2 — Installation et configuration de PostgreSQL

Strapi fonctionne avec PostgreSQL 11 et versions supérieures. Rocky Linux 9 inclut PostgreSQL 13 par défaut ; ici nous utilisons PostgreSQL 15.

Ajoutez la clé GPG du dépôt PostgreSQL :

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

Installez le dépôt :

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

Désactivez le module PostgreSQL intégré :

$ sudo dnf -qy module disable postgresql

Installez PostgreSQL 15 :

$ sudo dnf install -y postgresql15-server

Initialisez la base :

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

Activez et démarrez le service :

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

Vérifiez l’état :

$ sudo systemctl status postgresql-15

Exemple d’affichage (abrégé) :

? postgresql-15.service - PostgreSQL 15 database server
     Loaded: loaded (/usr/lib/systemd/system/postgresql-15.service; enabled; vendor preset: disabled)
     Active: active (running)

Créez la base et l’utilisateur Strapi :

$ 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

Testez la connexion :

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

strapidb=>

Tapez \q pour quitter.

Important : choisissez un mot de passe fort et stockez-le dans un gestionnaire sécurisé.

Étape 3 — Installation de Node.js

Rocky Linux 9 peut fournir Node v16 ; Strapi recommande souvent la dernière LTS. Ici nous utilisons Node.js v18.

Ajoutez le script NodeSource pour la v18 :

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

Installez Node.js :

$ sudo dnf install nodejs -y

Vérifiez la version :

$ node -v
v18.13.0

Étape 4 — Installation de Strapi

Créez le projet Strapi à l’aide de npx :

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

Répondez y puis choisissez l’installation : Custom et répondez aux questions :

? 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

Vous pouvez choisir JavaScript ou TypeScript selon vos préférences.

Accédez au répertoire du projet puis construisez l’interface d’administration :

$ cd howtoforge-project
$ NODE_ENV=production npm run build

Démarrez Strapi pour vérifier :

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

L’application sera accessible sur `http://:1337`. Ouvrez le port temporairement :

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

Une fois testé, stoppez le serveur (Ctrl + C) et supprimez la règle du pare-feu :

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

Écran d'accueil Strapi

Légende : Page d’accueil Strapi affichée sur un navigateur local.

Étape 5 — Gestion du processus avec PM2

Pour exécuter Strapi en production, utilisez PM2 pour gérer le processus et créer un service systemd.

Revenez dans votre répertoire personnel :

$ cd ~

Installez PM2 globalement :

$ sudo npm install pm2@latest -g

Créez le fichier de configuration PM2 :

$ sudo nano ecosystem.config.js

Collez et adaptez le contenu (changez cwd et les identifiants si nécessaire) :

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

Démarrez l’application via PM2 :

$ pm2 start ecosystem.config.js

Exécutez la commande de démarrage automatique pour systemd (copiez la commande fournie par la sortie de pm2 startup et exécutez-la avec sudo) :

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

Enregistrez la liste des processus PM2 :

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

Votre instance Strapi tourne maintenant en arrière-plan, redémarre automatiquement et est intégrée au démarrage système.

Étape 6 — Installation de Nginx

Pour utiliser la dernière version stable d’Nginx, ajoutez le dépôt officiel.

Créez le fichier de dépôt :

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

Collez :

[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

Installez Nginx :

$ sudo dnf install -y nginx

Vérifiez la version :

$ nginx -v
nginx version: nginx/1.22.1

Activez et démarrez Nginx :

$ sudo systemctl enable nginx --now
$ sudo systemctl status nginx

Étape 7 — Installation du certificat SSL (Certbot)

Nous utilisons snapd pour installer Certbot. Installez d’abord EPEL, puis 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
$ 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

Installez Certbot via snap :

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

Générez le certificat (remplacez l’email et le domaine) :

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

Le certificat sera placé dans /etc/letsencrypt/live/strapi.example.com.

Générez un paramètre Diffie-Hellman :

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

Testez le renouvellement :

$ sudo certbot renew --dry-run

Si tout est correct, le renouvellement automatique fonctionnera.

Étape 8 — Configuration de Nginx comme reverse proxy

Ouvrez /etc/nginx/nginx.conf et ajoutez :

server_names_hash_bucket_size  64;

Créez le fichier de configuration pour Strapi :

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

Collez (adaptez server_name au FQDN) :

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

Vérifiez la syntaxe et redémarrez Nginx :

$ sudo nginx -t
$ sudo systemctl restart nginx

Strapi devrait être accessible sur https://strapi.example.com.

Strapi en production

Légende : Page d’accueil Strapi en mode production.

Accédez à /admin pour créer l’utilisateur administrateur :

Création utilisateur admin Strapi

Remplissez les informations et cliquez sur le bouton “Let’s start” pour ouvrir le tableau de bord :

Tableau de bord admin Strapi

Légende : Tableau de bord administrateur Strapi.

Étape 9 — Mise à jour de Strapi

Avant de mettre à jour, arrêtez l’instance PM2 :

$ cd ~
$ pm2 stop ecosystem.config.js

Ouvrez le package.json du projet et mettez à jour les versions des paquets Strapi et plugins vers la dernière version stable (vérifiez la page des releases Strapi sur GitHub). Exemple :

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

Remplacez 4.5.5 par la version souhaitée, en respectant les notes de migration officielles.

Installez, reconstruisez l’admin et redémarrez :

$ npm install
$ NODE_ENV=production npm run build
$ cd ~
$ pm2 start ecosystem.config.js

Vérifiez le fonctionnement et les logs (pm2 logs) puis testez les API et l’interface.

Renforts opérationnels et bonnes pratiques

Encadré : chiffres et recommandations clés

RAM recommandée : 2–4 Go pour déploiements légers; 8+ Go pour production avec trafic.
Port interne Strapi : 1337 (assurez-vous qu’il ne soit pas exposé en dehors du proxy).
PostgreSQL : versions 11+ compatibles; privilégiez 13–15.
Node.js : utilisez la LTS active (v18 au moment de la rédaction).

Remarque : ces valeurs sont indicatives et dépendent de l’usage.

Checklist rôle par rôle

Administrateur système :

Configurer un utilisateur non-root avec sudo.
Mettre en place sauvegarde régulière des bases PostgreSQL.
Configurer monitoring (CPU, mémoire, disque, processus PM2).

Développeur / Mainteneur Strapi :

Valider les migrations et plugins avant mise à jour.
Tester la build d’administration localement avant déploiement.
Utiliser des variables d’environnement sécurisées (pas de secrets dans le dépôt).

Sécurité / Responsable conformité :

Forcer HTTPS via Nginx et interdire l’accès direct sur le port 1337.
Restreindre l’accès à l’admin via IP ou authentification supplémentaire si nécessaire.
Activer les sauvegardes chiffrées et conserver les clés en sécurité.

Runbook incident minimal (arrêt / rollback)

Symptôme : l’admin Strapi inaccessible après mise à jour.
Vérifier les logs : pm2 logs strapi et sudo journalctl -u pm2-.
Si build cassée : revenir au tag/commit précédent du projet.
Restaurer package.json et exécuter npm install puis NODE_ENV=production npm run build.
Redémarrer PM2 : pm2 restart ecosystem.config.js.
Si la base a été modifiée par une migration : restaurer la sauvegarde PostgreSQL si nécessaire.

Méthodologie de mise à jour (mini-sop)

Cloner le dépôt dans un environnement de staging.
Mettre à jour les dépendances Strapi.
Lancer npm install puis npm run build et exécuter des tests manuels/automatisés.
Migrer la base si la version l’exige (consultez la doc Strapi).
Planifier la fenêtre de maintenance en production.
Sauvegarder la base et les fichiers avant déploiement.
Déployer et vérifier les endpoints critiques.

Critères d’acceptation / tests basiques

L’interface /admin s’affiche et l’authentification admin fonctionne.
Les endpoints public API renvoient des réponses 200 sur les ressources de test.
Les actions CRUD sur un contenu personnalisé réussissent.
Les certificats TLS sont valides et le site force le HTTPS.

Sécurité & durcissement

Désactiver l’accès direct au port 1337 depuis Internet ; n’autorisez que 127.0.0.1 pour le proxy.
Garder Node.js et PostgreSQL à jour avec les correctifs de sécurité.
Réduire les informations retournées dans les erreurs en production (NODE_ENV=production).
Limiter les privilèges de l’utilisateur PostgreSQL (ne pas utiliser postgres en production pour l’app).
Surveiller les logs et configurer alertes (ex. perte de heartbeat PM2, échecs de renouvellement Certbot).

Confidentialité / Remarques GDPR

Si vous traitez des données personnelles, documentez les flux de données entre Strapi, les plugins et des tiers.
Activez les contrôles d’accès (roles & permissions) et limitez les exports/exportations de données.
Prévoyez des sauvegardes chiffrées et des procédures de suppression conformes aux demandes de droits (droit à l’oubli).

Conseils de migration et compatibilité

Lisez toujours les notes de migration entre versions majeures de Strapi.
Les plugins tiers peuvent nécessiter des mises à jour ou des remplacements.
Testez les API publiques et les hooks avant toute mise en production.

Glossaire (1 ligne chacun)

FQDN : nom de domaine entièrement qualifié (ex. strapi.example.com).
PM2 : gestionnaire de processus pour applications Node.js.
Certbot : client pour obtenir certificats Let’s Encrypt.
Reverse proxy : serveur qui relaie les requêtes HTTP(s) vers l’application interne.

Scénarios où cette approche peut échouer

Environnements avec des politiques réseau strictes empêchant l’installation de snapd ou l’accès à Let’s Encrypt.
Utilisation d’un fournisseur de managed DB avec exigences spécifiques (modifications de connexion SSL).
Plugins Strapi non compatibles avec la version cible lors d’une mise à jour majeure.

Alternatives rapides

Utiliser un hébergeur PaaS (Heroku, Render, Railway) pour Strapi si vous ne souhaitez pas gérer l’infrastructure.
Remplacer Nginx par Traefik si vous utilisez beaucoup de services conteneurisés et souhaitez une intégration dynamique.
Utiliser une base MySQL/MariaDB si votre organisation standardise sur cet SGBD (vérifier compatibilité plugins).

Social preview (suggestions)

OG title suggestion : Installer Strapi sur Rocky Linux 9 avec Nginx et PM2 OG description suggestion : Tutoriel pas à pas pour déployer Strapi communautaire en production, avec PostgreSQL, PM2 et TLS.

Short announcement (130 mots) : Installez Strapi sur Rocky Linux 9 en suivant notre guide complet : configuration du pare-feu, PostgreSQL 15, Node.js 18, Strapi, PM2 pour la gestion des processus et Nginx avec certificat Let’s Encrypt. Inclus : checklist opératoire, runbook incident, bonnes pratiques de sécurité et instructions de mise à jour. Idéal pour déploiements auto-hébergés et environnements contrôlés.

Conclusion

Ce tutoriel vous a guidé depuis la préparation du serveur jusqu’à un déploiement Strapi sécurisé accessible via HTTPS. Adaptez les étapes à vos conventions (noms d’utilisateurs, chemins, outils de supervision) et testez systématiquement en staging avant production. Si vous avez des questions techniques, indiquez les erreurs exactes et les logs pour obtenir de l’aide ciblée.

Extras : sauvegardes régulières, monitoring et tests automatisés rendent la plateforme plus résiliente en production.

Installer Strapi (version communautaire) sur Rocky Linux 9 avec Nginx et PM2