Sécuriser et configurer Strapi pour la production

Avant tout, on définit nos variables sensibles dans un fichier .env. Strapi lit ces valeurs via env() :

Terminal

1# .env
2HOST=0.0.0.0
3PORT=1337
4APP_KEYS=key1,key2,key3
5DATABASE_CLIENT=postgres
6DATABASE_HOST=db.example.com
7DATABASE_PORT=5432
8DATABASE_NAME=strapi_prod
9DATABASE_USERNAME=strapi
10DATABASE_PASSWORD=supersecret
11DATABASE_SSL=true
12DATABASE_URL=postgres://strapi:supersecret@db.example.com:5432/strapi_prod
13STRAPI_TOKEN=monTokenPourWebhooks
14JWT_SECRET=unAutreSecretTresFort

Sécurise tes secrets

Ne commite jamais ton .env dans Git. Utilise Docker secrets ou ton CI/CD pour injecter ces valeurs en production.

On place dans config/server.ts la lecture des variables :

config/server.ts

1export default ({ env }) => ({
2  host: env('HOST', '0.0.0.0'),
3  port: env.int('PORT', 1337),
4  app: {
5    keys: env.array('APP_KEYS'), // ^? Clés de chiffrement pour les cookies et JWT
6  },
7  webhooks: {
8    defaultHeaders: {
9      Authorization: `Bearer ${env('STRAPI_TOKEN')}`, // ^? Protection des webhooks
10    },
11  },
12});

Dans config/database.ts, on active SSL pour PostgreSQL/MySQL :

config/database.ts

1import path from 'node:path';
2
3export default ({ env }) => {
4  const client = env('DATABASE_CLIENT', 'sqlite');
5  const commonSsl = env.bool('DATABASE_SSL', false) && {
6    rejectUnauthorized: env.bool('DATABASE_SSL_REJECT_UNAUTHORIZED', true),
7    key: env('DATABASE_SSL_KEY', undefined),
8    cert: env('DATABASE_SSL_CERT', undefined),
9    ca: env('DATABASE_SSL_CA', undefined),
10  };
11
12  const connections = {
13    postgres: {
14      connection: {
15        connectionString: env('DATABASE_URL'),
16        ssl: commonSsl, // ^? Active SSL si DATABASE_SSL=true
17      },
18      pool: { min: 2, max: 10 },
19    },
20    // ... autres clients (mysql, sqlite)
21  };
22
23  return {
24    connection: { client, ...connections[client] },
25  };
26};

Tip

Tester la connexion SSL localement avec psql "sslmode=require ...".

On utilise le middleware strapi::security pour ajouter des headers HTTP via Helmet :

config/middlewares.ts

1export default [
2  'strapi::errors',
3  {
4    name: 'strapi::security',
5    config: {
6      contentSecurityPolicy: {
7        directives: {
8          defaultSrc: ["'self'"],       // ^? Limite les sources de scripts
9          scriptSrc: ["'self'"],
10          styleSrc: ["'self'", "'unsafe-inline'"],
11          imgSrc: ["'self'", 'data:'],
12          connectSrc: ["'self'"],
13        },
14      },
15      hsts: { maxAge: 31536000, includeSubDomains: true },
16      xssProtection: true,
17      frameguard: { action: 'deny' },
18      noSniff: true,
19    },
20  },
21  'strapi::cors',
22  'strapi::csrf',
23  'strapi::poweredBy',
24  'strapi::logger',
25  'strapi::query',
26  'strapi::body',
27  'strapi::favicon',
28  'strapi::public',
29];

// @callout: Utilise strapi::cors et strapi::csrf pour bloquer // toute requête croisée non autorisée.

CSRF et CORS

Configure bien les origines (origin) dans config/middlewares.ts si ton front est sur un domaine différent.

On ajoute un middleware maison ou un plugin pour prévenir les DDoS :

config/plugins/rate-limit.ts

1export default {
2  enabled: true,
3  config: {
4    policy: 'distributed',
5    points: 100,          // 100 requêtes
6    duration: 60,         // par minute
7    keyPrefix: 'rl:',     // préfixe dans Redis (si utilisé)
8  },
9};

Puis on l’injecte dans middlewares.ts :

config/middlewares.ts

1@@
2-  'strapi::logger',
3+  'strapi::logger',
4+  { name: 'plugin::rate-limit', config: {} },

Change le chemin d’accès par défaut (/admin) :

config/admin.ts

1export default ({ env }) => ({
2  url: env('ADMIN_URL', '/secure-admin'), // ^? URL customisée
3  auth: {
4    secret: env('JWT_SECRET'),
5  },
6});

Active l’HTTPS sur ton proxy (Nginx, Traefik) :

Terminal

1# Exemple pour Traefik
2labels:
3  - "traefik.http.routers.strapi-secured.rule=Host(`shop.example.com`)"
4  - "traefik.http.routers.strapi-secured.tls=true"

Tip

Garde ton chemin /secure-admin secret et partage-le uniquement aux admin.

Exemple de fichier docker-compose.yml :

docker-compose.yml

1version: '3.8'
2services:
3  strapi:
4    image: strapi/strapi:5
5    env_file: .env
6    volumes:
7      - ./build:/srv/app/build
8      - ./config:/srv/app/config
9    ports:
10      - "${PORT}:${PORT}"
11    depends_on:
12      - db
13  db:
14    image: postgres:14
15    env_file: .env
16    volumes:
17      - db_data:/var/lib/postgresql/data
18volumes:
19  db_data: {}

Bonnes pratiques Docker

Utilise une image officielle
Ne mappe pas ton dossier node_modules
Stocke les données en volume

Logs : redirige stdout/stderr vers un outil de monitoring (ELK, Datadog…).
Backups : planifie des dumps de ta base (pg_dump, mysqldump) et de /public/uploads.
Health check : configure un endpoint /health pour Kubernetes ou ton orchestrateur.

Lire les env via env() dans config/*.ts.
Chiffrer cookies et JWT avec APP_KEYS / JWT_SECRET.
Activer SSL sur la base de données et le reverse proxy.
Protéger les routes avec Helmet, CORS, CSRF et rate limiting.
Sécuriser l’admin en personnalisant l’URL et en forçant HTTPS.
Docker : séparer code, données et config, utiliser des secrets.

Configurer un middleware
Dans config/middlewares.ts, ajoute un header Referrer-Policy: no-referrer.
Changer le chemin admin
Modifie config/admin.ts pour que l’UI soit accessible sur /gestion.
Tester le rate limiter
Écris un script Bash qui envoie 200 requêtes à ton API en 30 s. Observe le comportement.

Liens utiles :