Plane : héberger une alternative open-source à Jira

Plane est une plateforme de gestion de projet open-source, alternative à Jira, Linear, Monday et ClickUp : tâches, sprints, cycles, modules, documents et triage, dans une interface moderne et légère. Ce guide montre ce qu'est Plane en 2026 (devenu AI-native), ses éditions, son architecture, et surtout comment l'auto-héberger avec Docker Compose pour garder vos données chez vous. Public visé : équipes et administrateurs qui veulent l'agilité de Jira sans son coût ni son SaaS.

Ce que vous allez apprendre

Distinguer les éditions Community, Commercial et Air-Gapped
Comprendre l'architecture du stack Plane (services et dépendances)
Déployer Plane Community en self-hosted avec Docker Compose
Administrer l'instance avec le God mode
Situer les angles IA/MCP et sécurité de la plateforme

Qu'est-ce que Plane

Plane couvre le cycle de vie d'un projet agile : work items (tâches, bugs, Epics), cycles (sprints), modules, vues filtrées, pages (documentation type wiki) et triage des demandes. Le tout est open-source sous licence AGPL-3.0 pour l'édition Community, avec ~50 000 étoiles sur GitHub.

En 2026, Plane se positionne comme une plateforme AI-native : un assistant Plane AI (modes Ask et Build, recherche web) et des connecteurs MCP (Model Context Protocol) pour relier des outils externes, le tout déployable en BYOK (bring your own key) sur votre infrastructure, sans que les données quittent votre système.

Les éditions

Plane se décline en plusieurs éditions, valables aussi bien en cloud qu'en self-hosted :

Édition	Licence / Prix	Pour qui
Community	AGPL-3.0, gratuit	Self-host complet, équipes qui veulent la maîtrise
Pro	~6 $/siège/mois	Workflows, time tracking, formulaires d'intake
Business	~13 $/siège/mois	LDAP, fonctions avancées au-delà de ~12 utilisateurs
Air-Gapped	Commercial	Environnements isolés ou souverains, sans accès internet

Architecture du stack

Plane n'est pas un binaire unique mais un ensemble de microservices. Le déploiement self-hosted lance 13 conteneurs :

Conteneur	Rôle
web	Interface principale (frontend)
space	Vues publiques partagées
admin	Administration de l'instance (God mode)
live	Collaboration en temps réel
api	API applicative (Django)
proxy	Reverse proxy d'entrée (Caddy)
worker / beat-worker	Tâches asynchrones et planifiées (Celery)
migrator	Migrations de base de données (one-shot au démarrage)
plane-db	Base de données PostgreSQL 15
plane-redis	Cache Valkey (fork de Redis)
plane-mq	File de messages RabbitMQ
plane-minio	Stockage objet MinIO (compatible S3) pour les pièces jointes

Ce stack consomme de l'ordre de 2 Go de RAM une fois lancé : Plane n'est pas un service léger, prévoyez une machine adaptée.

Prérequis

Un serveur Linux ou une VM avec 4 Go de RAM minimum (le stack en utilise ~2 Go, plus la marge système)
Docker et Docker Compose installés
Un nom de domaine ou une IP pour WEB_URL
Quelques Go d'espace disque pour les images et les données

Déployer Plane Community en self-hosted

Le déploiement a quitté le dépôt principal : il se fait désormais via un script et des artefacts publiés avec chaque release.

Récupérer le script d'installation

mkdir plane-selfhost && cd plane-selfhost
curl -fsSL -o setup.sh https://github.com/makeplane/plane/releases/latest/download/setup.sh
chmod +x setup.sh

Installer (télécharge le compose et l'environnement)
Fenêtre de terminal
```
./setup.sh
```
Choisissez l'option 1 (Install). Le script crée docker-compose.yaml et un fichier plane.env.

Configurer l'environnement

Éditez plane.env pour adapter l'accès :

APP_RELEASE=v1.3.1
APP_DOMAIN=plane.mondomaine.fr
LISTEN_HTTP_PORT=80
WEB_URL=http://plane.mondomaine.fr
CORS_ALLOWED_ORIGINS=http://plane.mondomaine.fr

Démarrer les services
Fenêtre de terminal
```
./setup.sh        # option 2 (Start)
```
Ou, en pilotage direct (utile pour l'automatisation) :
Fenêtre de terminal
```
docker compose --env-file plane.env up -d
```
Vérifier
Fenêtre de terminal
```
docker compose --env-file plane.env ps
curl -s -o /dev/null -w '%{http_code}\n' http://localhost/
```
Une fois les 13 services lancés et les images téléchargées, la page d'accueil répond 200. Les services web, space et admin passent par un état health: starting le temps de leur initialisation.

Administrer l'instance avec le God mode

Plane sépare l'administration de l'instance (réglages globaux, comptes, authentification, intégrations) de l'usage projet. Cette console s'appelle le God mode et s'ouvre sur le chemin /god-mode/ :

http://plane.mondomaine.fr/god-mode/

C'est là que vous configurez l'authentification (e-mail, Google, GitHub, Gitea depuis la v1.3.1), les limites d'inscription, le mailer et les intégrations. Le premier compte créé devient l'administrateur de l'instance.

Travailler dans Plane : projets et work items

L'unité de base est le projet, qui regroupe une équipe, ses paramètres et son travail. À l'intérieur, tout est un work item (l'équivalent des issues de Jira) : tâche, bug, story. Chaque work item porte un état (workflow), un assigné, des étiquettes, une priorité, une date d'échéance et une description riche.

Plane structure le travail à plusieurs niveaux :

les sous-items (sub-issues) découpent un work item en étapes ;
les Epics (devenus un type de work item à part entière en 2026) regroupent un ensemble de work items autour d'un objectif large ;
les relations (blocks, blocked by, duplicate, relates to) relient les items entre eux.

Les workflows définissent les transitions d'état autorisées (par exemple Backlog vers In progress vers Done). Cadrer ces états donne une lecture homogène de l'avancement à toute l'équipe.

Planifier avec les cycles et les modules

Deux mécanismes complémentaires organisent la planification :

Concept	Rôle	Équivalent agile
Cycle	Période de travail bornée dans le temps, avec un objectif	Sprint
Module	Regroupement de work items par fonctionnalité ou chantier	Epic / feature transverse

Un cycle suit la vélocité : graphe d'avancement (burndown), items terminés contre prévus, ce qui glisse au cycle suivant. Un module suit une livraison fonctionnelle qui peut s'étaler sur plusieurs cycles. Un même work item peut appartenir à un cycle et à un module.

Visualiser et documenter

Plane affiche le même travail sous plusieurs dispositions (layouts), selon le besoin du moment :

Liste (list) et Kanban (board) pour le suivi quotidien ;
Calendrier (calendar) pour les échéances ;
Tableur (spreadsheet) pour l'édition en masse ;
Gantt (timeline) pour les dépendances et le planning.

À ne pas confondre avec les vues (views), qui figent un jeu de filtres (assigné, priorité, étiquette, état) que l'on enregistre et partage avec l'équipe. À côté des work items, les Pages offrent une documentation de type wiki, éditable en collaboration et reliable aux projets, pour garder décisions et spécifications près du travail.

Recevoir et trier les demandes

La fonction intake (triage) ouvre une boîte de réception de demandes entrantes : un utilisateur ou un formulaire crée une demande, qui n'entre pas directement dans le backlog. Un responsable la trie (accepter, refuser, fusionner) avant qu'elle ne devienne un work item. C'est utile pour filtrer le bruit sur un projet exposé (support, retours utilisateurs).

Migrer depuis Jira

Plane fournit des importeurs pour ne pas repartir de zéro. Depuis les paramètres de l'espace de travail (Import data), vous pouvez importer depuis Jira, Linear, Asana, ClickUp, Notion, Confluence, Flatfile et des fichiers CSV. L'import récupère les items, leurs états et leurs métadonnées principales ; prévoyez une phase de recette pour vérifier la correspondance des champs et des workflows avant de basculer une équipe en production.

Automatiser avec l'API et les webhooks

Plane expose une API REST pour scripter et intégrer la plateforme :

générez un jeton d'API dans vos paramètres, puis appelez les endpoints (projets, work items, cycles, modules) avec ce jeton en en-tête ;
les webhooks notifient un système externe à chaque événement (création ou mise à jour d'un work item), pour déclencher une CI, une notification ou une synchronisation.

Plane AI et MCP

L'atout différenciant de Plane en 2026 est son ouverture à l'IA sans sacrifier la souveraineté :

Plane AI assiste la rédaction et l'organisation (modes Ask / Build).
Les connecteurs MCP relient Plane à des outils externes via le Model Context Protocol, et il est possible de publier des applications MCP depuis Plane.
Le mode BYOK (bring your own key) en self-hosted garde le traitement chez vous : les données ne partent pas vers un service tiers.

Pour comprendre le protocole derrière ces connecteurs, voyez ce qu'est le MCP.

Sécurité et durcissement

Auto-héberger Plane, c'est aussi en assumer la sécurité. Quelques points clés :

Mettre TLS en façade : le proxy interne écoute en HTTP ; placez Plane derrière un reverse proxy chiffré ou activez le HTTPS du proxy. Voyez Traefik ou la terminaison TLS.
Webhooks et SSRF : depuis la v1.3.1, les webhooks bloquent par défaut les adresses privées ; n'autorisez que les réseaux nécessaires via WEBHOOK_ALLOWED_IPS.
Suivre les correctifs : Plane publie des avis GHSA (injection, traversée de chemin, SSRF). Surveillez les releases et mettez à jour.
Sauvegarder : les données vivent dans PostgreSQL (projets) et MinIO (pièces jointes). Sauvegardez les deux ; la release fournit un restore.sh.

Plane contre Jira

Critère	Plane (Community)	Jira
Licence	Open-source AGPL-3.0	Propriétaire
Hébergement	Self-host ou cloud	Cloud (ou Data Center payant)
Coût de base	Gratuit en self-host	Par utilisateur
Données	Chez vous (self-host)	Chez Atlassian (cloud)
Complexité	Légère, prise en main rapide	Riche mais lourde
IA / MCP	Plane AI + connecteurs MCP, BYOK	Atlassian Intelligence (SaaS)

Règle simple : si vous voulez l'agilité sans la lourdeur ni le coût, et maîtriser vos données, Plane self-hosted est un choix solide. Jira reste pertinent pour les très grandes organisations déjà investies dans l'écosystème Atlassian.

Dépannage

Symptôme	Cause probable	Solution
La page d'accueil renvoie 502	Services encore en `health: starting`	Attendre l'initialisation, vérifier `docker compose ps`
Conteneurs qui redémarrent en boucle	RAM insuffisante	Passer à 4 Go, vérifier `docker stats`
Impossible de se connecter (CORS)	`CORS_ALLOWED_ORIGINS` différent de `WEB_URL`	Aligner les deux sur la même URL
Pièces jointes non enregistrées	MinIO mal configuré ou plein	Vérifier le conteneur `plane-minio` et l'espace disque
God mode inaccessible	Mauvais chemin	Utiliser `/god-mode/` (et non `/admin/`)

À retenir

Plane est une alternative open-source (AGPL) à Jira/Linear, devenue AI-native en 2026
Trois éditions : Community (gratuite), Pro/Business (payantes), Air-Gapped (isolé)
Le self-host est un stack de 13 conteneurs (~2 Go de RAM) : prévoyez une VM 4 Go
Déploiement via setup.sh ou Docker Compose + plane.env
L'administration de l'instance passe par le God mode (/god-mode/)
Atouts 2026 : MCP/BYOK, login Gitea, RBAC à deux couches, correctifs de sécurité réguliers

Prochaines étapes

Forgejo : la forge Git self-hosted Compléter Plane par une forge Git auto-hébergée, avec login partagé possible (Gitea/Forgejo).

GitLab L'alternative tout-en-un qui combine forge Git et gestion de projet.

Docker Compose Maîtriser l'outil qui orchestre le stack Plane multi-conteneurs.

Comprendre le MCP Le protocole derrière les connecteurs IA de Plane.