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 :

Une seule commande installe tout :

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.

La seule dépendance externe est MongoDB : le backend se connecte à un cluster MongoDB Atlas, que vous fournissez. Tout le reste s'exécute à l'intérieur du conteneur.

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).

Tout le reste — Bun, Redis, MinIO, Chromium — est fourni dans l'image.

Démarrage rapide

1. Exécuter l'installateur

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

Il vérifie que Docker est installé et en cours d'exécution, écrit ./intlayer.env avec BETTER_AUTH_SECRET et S3_SECRET_ACCESS_KEY déjà générés, et télécharge l'image. Il ne démarre pas le conteneur — le backend ne peut pas démarrer sans vos identifiants de base de données.

Réexécuter l'installateur est sûr : un intlayer.env existant n'est jamais écrasé, il sert donc également de chemin de mise à niveau.

2. Remplissez vos identifiants

Ouvrez intlayer.env et complétez les valeurs marquées TODO :

DB_ID=<atlas-user>
DB_MDP=<atlas-password>
DB_CLUSTER=<cluster>.xxxxx.mongodb.net
RESEND_API_KEY=<your-resend-key>

Le fichier contient également des blocs commentés pour les fonctionnalités optionnelles — SMTP mailer, OPENAI_API_KEY, et les fournisseurs OAuth. Décommentez ce dont vous avez besoin.

Le fichier est lu par docker run --env-file, qui ne supprime pas les guillemets et traite tout ce qui suit = comme la valeur. Écrivez des valeurs nues et gardez les commentaires sur leurs propres lignes.

3. Démarrer le conteneur

Ceci est la commande que l'installateur affiche à la fin :

docker run -d --name intlayer \
  --restart unless-stopped \
  -p 3000:3000 \
  -p 3100:3100 \
  -p 9000:9000 \
  -p 9001:9001 \
  -v intlayer-data:/data \
  --env-file ./intlayer.env \
  ghcr.io/aymericzip/intlayer-selfhost:latest

Ouvrez ensuite http://localhost:3000. Le premier démarrage initialise les datastores, donc patientez une minute.

Le tableau de bord est servi sur localhost. Voir Limitations — les domaines personnalisés ne sont pas pris en charge par l'image publiée.

Paramètres du programme d'installation

Le programme d'installation lit quelques variables d'environnement. Comme il est dirigé vers sh, transmettez-les au shell plutôt qu'à curl :

curl -fsSL https://intlayer.org/install.sh | INTLAYER_ENV_FILE=./config/intlayer.env sh

Les quatre variables de port ne modifient que le côté hôte du mappage imprimé dans la commande docker run. L'image publiée a http://localhost:3000, http://localhost:3100 et http://localhost:9000 compilés dans le bundle du tableau de bord au moment de la compilation, donc les remapper laisse le navigateur pointant vers les anciens ports. Conservez les valeurs par défaut sauf si vous construisez votre propre image — voir Limitations.

Configuration initiale

Sur une instance vierge (base de données vide), l'ouverture du dashboard vous redirige vers la page /init :

1. Créez le premier compte. Comme la collection users est vide, ce compte est automatiquement promu super admin.
2. Un email de vérification est envoyé (via Resend). La vérification d'email est obligatoire — c'est pourquoi RESEND_API_KEY doit être défini avant de commencer.
3. Cliquez sur le lien dans l'email, puis connectez-vous.

Une fois qu'un admin existe, /init redirige vers la page de connexion standard.

Services

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

Requis

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

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

Mailer global

Par défaut, tous les emails transactionnels sont envoyés via Resend en utilisant RESEND_API_KEY. Les déploiements auto-hébergés peuvent à la place router tous les emails — y compris les emails non-organisationnels tels que les réinitialisations de mot de passe et les liens magiques — via un mailer global configuré avec des variables d'environnement.

Définissez MAIL_PROVIDER pour l'activer. S'il n'est pas défini, le mailer Resend par défaut est utilisé.

Priorité : le mailer propre d'une organisation (configuré depuis le tableau de bord Organization) a priorité sur le mailer global, qui a lui-même priorité sur la clé Resend par défaut.

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:3000
INTLAYER_BACKEND_URL=http://localhost:3100
INTLAYER_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

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.

docker compose pull
docker 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 /data

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

docker 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

Limitations

• MongoDB must be external (Atlas). The backend connects only over mongodb+srv:// (built from DB_ID / DB_MDP / DB_CLUSTER), so a plain mongodb://host:27017 — including the container's own bundled mongod — cannot be used. Provide a MongoDB Atlas cluster.
• No custom domain. All browser-facing VITE_* URLs are inlined into the app at build time, and the published image ships with localhost values. The dashboard must be accessed at http://localhost:3000; serving it on a public domain would require rebuilding the image with the target URLs baked in and is not supported out of the box.
• Email requires a working mailer. First-run setup enforces email verification, so either RESEND_API_KEY or a global SMTP mailer (MAIL_PROVIDER=smtp + MAIL_SMTP_*) must be configured. After the first admin signs in, each organization can also configure its own SMTP or Resend mailer from the dashboard.

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 ps
docker compose logs mongo
docker compose logs redis

Recherchez MongoDB connection error près du haut du journal.

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 :

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
• Docker Image (aymercizip/intlayer-selfhost)