Auto-hébergement d'Intlayer

Intlayer peut fonctionner entièrement sur votre propre infrastructure — aucun compte Intlayer Cloud n'est requis. Une seule commande démarre une stack prête pour la production :

curl -fsSL https://intlayer.org/install.sh | sh

L'installateur télécharge un fichier docker-compose.yml et un fichier .env, génère automatiquement les secrets requis et démarre tous les conteneurs avec docker compose up -d.

Table des matières

Architecture

                ┌─────────────────────────────┐ browser ──────▶ │  app  (TanStack Start)  :3000│ ──┐                └─────────────────────────────┘   │ VITE_BACKEND_URL                ┌─────────────────────────────┐   │                │  backend (Fastify/Bun)  :3100│ ◀─┘                └──────────────┬──────────────┘          ┌──────────┬─────────┼──────────┬───────────┐          ▼          ▼         ▼          ▼           ▼     mongo:27017  redis:6379  minio:9000  mailpit:1025  Chromium     (1-node RS)             (S3 API)     (SMTP)        (in-image)                             minio:9001   mailpit:8025                             (console)    (web UI)

Chromium (utilisé pour la génération de captures d'écran Puppeteer) est intégré à l'image du backend — aucun conteneur séparé n'est nécessaire.

Prérequis

• Docker ≥ 24 et Docker Compose ≥ v2. Si l'un des deux est manquant, l'installateur affiche le lien d'installation et quitte.
• Ports 3000, 3100, 8025, 9000 et 9001 disponibles sur l'hôte.
• Un hôte Linux ou macOS (ou WSL2 sur Windows).

Démarrage rapide

curl -fsSL https://intlayer.org/install.sh | sh

Ce que fait l'installateur :

1. Vérifie que docker et docker compose sont présents.
2. Télécharge docker-compose.yml et .env.example dans ./intlayer/.
3. S'il n'existe pas de fichier .env, copie l'exemple et génère des secrets aléatoires pour BETTER_AUTH_SECRET, S3_ACCESS_KEY_ID et S3_SECRET_ACCESS_KEY via openssl rand.
4. Exécute docker compose pull + docker compose up -d.
5. Affiche les URL : tableau de bord :3000, API :3100, UI e-mail :8025, console MinIO :9001.

Une fois la stack démarrée, ouvrez http://localhost:3000 et créez votre premier compte.

Services

Les ports internes (mongo, redis) ne sont pas exposés à l'hôte par défaut.

Le port 9000 de MinIO doit être accessible par le navigateur car les assets téléchargés (avatars, captures d'écran) sont chargés directement depuis S3_PUBLIC_URL=http://localhost:9000/intlayer.

Variables d'environnement

L'installateur génère un fichier .env prêt à l'emploi. Le tableau ci-dessous décrit chaque variable.

Requis (auto-généré ou demandé)

Facultatif (les fonctionnalités se dégradent gracieusement en leur absence)

Connexion de votre projet Intlayer

Une fois la stack en cours d'exécution, pointez votre projet vers le backend et le tableau de bord auto-hébergés au lieu de intlayer.org.

Configuration du projet

import type { IntlayerConfig } from "intlayer";

const config: IntlayerConfig = {
  editor: {
    clientId: process.env.INTLAYER_CLIENT_ID,
    clientSecret: process.env.INTLAYER_CLIENT_SECRET,

    /**
     * URL du tableau de bord CMS auto-hébergé.
     * Par défaut : https://app.intlayer.org
     */
    cmsURL: process.env.INTLAYER_CMS_URL, // ex. http://localhost:3000

    /**
     * URL de l'API backend auto-hébergée.
     * Par défaut : https://back.intlayer.org
     */
    backendURL: process.env.INTLAYER_BACKEND_URL, // ex. http://localhost:3100
  },
};

export default config;

Définissez les variables d'environnement dans le fichier .env de votre projet :

INTLAYER_CMS_URL=http://localhost:3000INTLAYER_BACKEND_URL=http://localhost:3100INTLAYER_CLIENT_ID=<your-client-id>INTLAYER_CLIENT_SECRET=<your-client-secret>

Créez des identifiants d'accès dans votre tableau de bord auto-hébergé sous Projets → Clés d'accès à l'adresse http://localhost:3000/projects.

SDK @intlayer/api

Lorsque vous utilisez le SDK @intlayer/api de manière programmatique, passez backendURL explicitement :

import { createIntlayerCMS } from "@intlayer/api";import { dictionaryEndpoint } from "@intlayer/api/dictionary";const cms = createIntlayerCMS({  editor: {    clientId: process.env.INTLAYER_CLIENT_ID,    clientSecret: process.env.INTLAYER_CLIENT_SECRET,    backendURL: process.env.INTLAYER_BACKEND_URL, // http://localhost:3100  },});const { data: dictionaries } = await dictionaryEndpoint(cms).getDictionaries();

Mise à niveau

Exécuter à nouveau l'installateur sur un déploiement existant effectue une mise à niveau progressive :

curl -fsSL https://intlayer.org/install.sh | sh

Ceci télécharge les dernières images et redémarre les conteneurs avec docker compose pull && docker compose up -d. Les volumes existants (mongo-data, redis-data, minio-data) sont préservés — aucune perte de données.

Pour effectuer une mise à niveau manuellement depuis le répertoire ./intlayer/ :

docker compose pulldocker compose up -d

Sauvegarde et restauration

Toutes les données persistantes résident dans trois volumes Docker nommés.

Sauvegarde

docker run --rm \  -v intlayer_mongo-data:/data \  -v "$(pwd)":/backup \  busybox tar czf /backup/mongo-data.tar.gz /datadocker run --rm \  -v intlayer_redis-data:/data \  -v "$(pwd)":/backup \  busybox tar czf /backup/redis-data.tar.gz /datadocker run --rm \  -v intlayer_minio-data:/data \  -v "$(pwd)":/backup \  busybox tar czf /backup/minio-data.tar.gz /data

Restauration

docker run --rm \  -v intlayer_mongo-data:/data \  -v "$(pwd)":/backup \  busybox tar xzf /backup/mongo-data.tar.gz -C /# Répétez pour redis-data et minio-data

Utilisation d'un proxy inverse (Nginx / Caddy)

Pour les déploiements de production, placez un proxy inverse devant les conteneurs de l'application et du backend au lieu de les exposer directement.

Exemple Nginx

server {    listen 80;    server_name cms.example.com;    location / {        proxy_pass http://localhost:3000;        proxy_set_header Host $host;        proxy_set_header X-Real-IP $remote_addr;    }}server {    listen 80;    server_name api.example.com;    location / {        proxy_pass http://localhost:3100;        proxy_set_header Host $host;        proxy_set_header X-Real-IP $remote_addr;    }}

Mettez à jour les variables .env suivantes pour qu'elles correspondent à vos domaines publics :

BACKEND_URL=https://api.example.comAPP_URL=https://cms.example.comDOMAIN=example.comVITE_BACKEND_URL=https://api.example.comVITE_DOMAIN=example.com

Les variables VITE_* sont intégrées à l'image du tableau de bord lors de la construction. Si vous les modifiez après la construction de l'image, vous devez reconstruire l'image app (docker compose build app) ou utiliser l'injection de configuration au moment de l'exécution.

Dépannage

Le backend redémarre en boucle au premier démarrage

MongoDB et Redis doivent être sains avant le démarrage du backend. Le fichier compose utilise depends_on avec condition: service_healthy. Si vous voyez des redémarrages répétés du backend, vérifiez que les contrôles de santé de mongo et redis sont réussis :

docker compose psdocker compose logs mongodocker compose logs redis

Le tableau de bord ne peut pas atteindre l'API

Vérifiez que VITE_BACKEND_URL correspond à l'URL où le backend est accessible depuis le navigateur (pas le réseau Docker). Si vous avez modifié le port du backend ou ajouté un proxy inverse, reconstruisez l'image du tableau de bord :

docker compose build appdocker compose up -d app

Les e-mails ne sont pas envoyés

Par défaut, tous les e-mails sortants sont capturés par Mailpit. Ouvrez http://localhost:8025 pour voir les messages envoyés. Pour envoyer de vrais e-mails, définissez MAIL_PROVIDER=resend et RESEND_API_KEY=<your-key> dans .env, puis redémarrez le backend :

docker compose restart backend

Bucket MinIO manquant

Si le service ponctuel minio-init n'a pas fonctionné (ou a fonctionné avant que MinIO ne soit prêt), créez le bucket manuellement :

docker compose run --rm minio-init

Liens utiles

• Documentation du CMS Intlayer
• Référence de configuration
• SDK CMS — @intlayer/api