Guide Complet ERPNext 2026 : Installation, Configuration et Développement Personnalisé d'un ERP Open Source

Pour les PME, le principal obstacle à la transformation numérique n'est souvent pas la volonté, mais le coût. Les ERP traditionnels (comme SAP ou Oracle) exigent des licences se chiffrant en centaines de milliers, voire en millions, ce qui les rend inaccessibles pour la plupart des petites et moyennes entreprises. Et les alternatives gratuites sont souvent incomplètes, avec des interfaces vieillissantes et un suivi inexistant.

ERPNext change la donne. En tant que système ERP (Enterprise Resource Planning) 100 % gratuit et open source, ERPNext offre une solution complète couvrant les modules métiers essentiels : finance, CRM, ventes, achats, stocks, fabrication et ressources humaines. Construit sur le framework Frappe, avec une stack Python + JavaScript, il propose une interface Web moderne et de puissantes capacités de développement personnalisé.

Dans ce guide, nous allons partir de zéro pour installer et déployer ERPNext, configurer les paramètres de base, utiliser les modules clés, et plonger dans le développement personnalisé — pour vous aider à mettre en place rapidement un ERP d'entreprise adapté à votre activité.

Qu'est-ce qu'ERPNext ?

ERPNext est un ERP open source développé et maintenu par la société indienne Frappe Technologies, publié sous licence GNU General Public License (GPL) v3. Cela signifie que vous pouvez :

• ✅ L'utiliser gratuitement — aucun frais de licence
• ✅ Le modifier librement — personnalisez les fonctionnalités selon vos besoins
• ✅ L'utiliser en environnement commercial — sans limite d'utilisateurs
• ✅ Bénéficier d'un écosystème communautaire — une communauté mondiale active contribue au code et aux plugins

Architecture technique

┌─────────────────────────────────────┐
│         ERPNext (couche applicative) │
│  Finance | CRM | Ventes | Achats | Stocks | RH │
├─────────────────────────────────────┤
│     Frappe Framework (couche framework)      │
│  DocType | API REST | Permissions | Workflows  │
├─────────────────────────────────────┤
│  Python (backend) | MariaDB (base de données) │
│  JavaScript/Vue (frontend) | Redis (cache) │
└─────────────────────────────────────┘

Le cœur d'ERPNext est le Frappe Framework, un framework Web full-stack écrit en Python. Sa principale force réside dans ses capacités Low-Code/No-Code : en définissant des DocType (types de documents), vous pouvez rapidement créer des modèles de données, des formulaires, des vues en liste et des API sans écrire des tonnes de code.

Pourquoi choisir ERPNext ?

Installation et déploiement

ERPNext prend en charge plusieurs modes de déploiement. Cette section détaille les trois plus courants : déploiement Docker (recommandé), installation manuelle et hébergement Frappe Cloud.

Option 1 : Déploiement Docker (recommandé)

Le déploiement Docker est la méthode d'installation la plus simple et la plus propre, adaptée aux tests rapides comme aux environnements de production.

Configuration système requise

• CPU : 2 cœurs minimum
• RAM : 4 Go minimum (8 Go recommandés)
• Stockage : 20 Go minimum
• Système d'exploitation : Ubuntu 20.04/22.04, CentOS 8+, Debian 11+

Déploiement en une commande avec docker-compose

# 1. Installer Docker et Docker Compose
curl -fsSL https://get.docker.com | sh
sudo systemctl enable --now docker

# 2. Installer Docker Compose (si non inclus)
sudo apt install docker-compose-plugin

# 3. Cloner la configuration docker-compose officielle
git clone https://github.com/frappe/frappe_docker.git
cd frappe_docker

# 4. Créer le fichier de variables d'environnement
cp example.env .env

# Éditer le fichier .env et définir les paramètres clés :
# SITE_NAME=erp.yourdomain.com
# DB_ROOT_USER=root
# DB_ROOT_PASSWORD=votre_mot_de_passe_securise
# ADMIN_PASSWORD=votre_mot_de_passe_admin

# 5. Démarrer les services
docker compose -f compose.yaml \
  -f overrides/compose.mariadb.yaml \
  -f overrides/compose.redis.yaml \
  -f overrides/compose.noproxy.yaml \
  config > ~/docker-compose.yml

docker compose -f ~/docker-compose.yml up -d

# 6. Créer un nouveau site
docker compose -f ~/docker-compose.yml exec backend \
  bench new-site erp.yourdomain.com \
  --mariadb-root-password votre_mot_de_passe_securise \
  --admin-password votre_mot_de_passe_admin \
  --install-app erpnext

# 7. Accéder à ERPNext
# Ouvrir http://votre-ip-serveur:8080 dans le navigateur
# Compte administrateur par défaut : Administrator
# Mot de passe : ADMIN_PASSWORD défini dans .env

Configurer un reverse proxy Nginx (environnement de production)

# Obtenir un certificat SSL gratuit avec Let's Encrypt
docker compose -f ~/docker-compose.yml exec backend \
  bench setup nginx

# Ou utiliser Traefik pour gérer automatiquement le HTTPS
docker compose -f compose.yaml \
  -f overrides/compose.traefik.yaml \
  config > ~/docker-compose-traefik.yml

docker compose -f ~/docker-compose-traefik.yml up -d

Option 2 : Installation manuelle (pour personnalisation avancée)

L'installation manuelle convient aux développeurs qui souhaitent personnaliser et déboguer le système en profondeur.

# 1. Installer les dépendances
sudo apt update
sudo apt install python3-dev python3-setuptools python3-pip \
  python3-distutils python3.10-venv software-properties-common \
  mariadb-server mariadb-client redis-server nodejs npm \
  yarn cron xvfb libfontconfig wkhtmltopdf

# 2. Configurer MariaDB
sudo mysql -u root -e "
  CREATE DATABASE erpnext;
  CREATE USER 'erpnext'@'localhost' IDENTIFIED BY 'your_password';
  GRANT ALL PRIVILEGES ON erpnext.* TO 'erpnext'@'localhost';
  FLUSH PRIVILEGES;
"

# 3. Installer bench (outil CLI de Frappe)
pip3 install frappe-bench

# 4. Initialiser bench
bench init --frappe-branch version-15 frappe-bench
cd frappe-bench

# 5. Créer un nouveau site
bench new-site erp.yourdomain.com \
  --db-name erpnext \
  --db-password your_password \
  --admin-password your_admin_password

# 6. Installer l'application ERPNext
bench get-app --branch version-15 erpnext
bench --site erp.yourdomain.com install-app erpnext

# 7. Démarrer le serveur de développement
bench start
# Accéder à http://localhost:8000

Option 3 : Hébergement Frappe Cloud

Si vous ne souhaitez pas gérer vous-même un serveur, utilisez le service d'hébergement officiel Frappe Cloud :

• Prix : 50 $/mois (plan petite entreprise)
• Inclus : utilisateurs illimités, sauvegardes automatiques, certificat SSL, support technique
• Adapté à : les PME sans équipe d'exploitation informatique

Il suffit de s'inscrire sur frappecloud.com, aucune compétence technique requise.

Configuration de base

Après l'installation, la première étape consiste à effectuer la configuration de base.

1. Paramètres de l'entreprise

Allez dans Paramètres → Entreprise et ajoutez les informations de votre entreprise :

• Nom de l'entreprise
• Adresse enregistrée
• Numéro de taxe
• Devise par défaut
• Mois de début de l'exercice comptable

# Architecture multi-entreprises
Si votre groupe possède plusieurs filiales, vous pouvez ajouter
plusieurs entreprises. ERPNext prend en charge les transactions
interentreprises et les états financiers consolidés.

2. Utilisateurs et permissions

ERPNext utilise un contrôle d'accès basé sur les rôles (RBAC) :

Administrateur système (System Manager) → tous les droits
Responsable comptabilité (Accounts Manager) → module finance
Responsable ventes (Sales Manager) → module ventes
Responsable stock (Stock Manager) → module stock
Responsable RH (HR Manager) → module ressources humaines

Créer un utilisateur

# Créer un utilisateur via l'API Frappe (script Python)
import frappe

user = frappe.get_doc({
    "doctype": "User",
    "email": "zhangsan@company.com",
    "first_name": "张三",
    "roles": [{"role": "Sales Manager"}]
})
user.insert()

3. Importation des données de base

ERPNext permet d'importer en masse des données de base via Excel/CSV :

Dans chaque module, accédez à Vue en liste → Importer, téléchargez le modèle, remplissez les données, puis importez-le.

4. Personnalisation des modèles d'impression

ERPNext vous permet de personnaliser le format d'impression de divers documents métiers :

• Factures
• Bons de commande
• Commandes de vente
• Bons de livraison
• Devis

Allez dans Paramètres → Paramètres d'impression pour choisir un modèle intégré ou personnaliser en HTML/Jinja.

Modules clés en détail

ERPNext comprend plus de 20 modules métiers. Voici les modules les plus utilisés.

💰 Module Finance (Accounting)

La finance est au cœur de tout ERP. Le module finance d'ERPNext est complet et bien structuré.

Plan comptable (Chart of Accounts)

ERPNext intègre des plans comptables conformes aux normes de nombreux pays, entièrement personnalisables :

Actifs (Assets)
├── Actifs courants
│   ├── Trésorerie et équivalents
│   ├── Créances clients
│   └── Stocks
├── Actifs immobilisés
│   ├── Bâtiments
│   └── Équipements
Passifs (Liabilities)
├── Passifs courants
│   ├── Fournisseurs
│   └── Emprunts à court terme
Capitaux propres (Equity)
├── Capital social
└── Réserves et résultats
Produits (Income)
├── Produits d'exploitation
└── Autres produits
Charges (Expenses)
├── Coût des ventes
├── Frais de vente
├── Frais administratifs
└── Frais financiers

Écritures comptables automatiques

Les opérations de vente, d'achat et de stock dans ERPNext génèrent automatiquement les écritures comptables :

# Écriture automatique pour une facture de vente
Débit : Créances clients         10 000 ¥
    Crédit : Produits d'exploitation     8 849,56 ¥
            TVA collectée                1 150,44 ¥

# Écriture automatique pour une réception d'achat
Débit : Marchandises en stock    5 000 ¥
    Crédit : Fournisseurs              5 000 ¥

Rapports financiers

• Bilan — reflète en temps réel la situation financière
• Compte de résultat — agrège les produits et charges par période
• Tableau des flux de trésorerie — suit les entrées et sorties de cash
• Analyse d'âge des créances/fournisseurs — surveille les risques de recouvrement

📦 Module Stock

Gestion des entrepôts

Prise en charge multi-entrepôts et multi-emplacements :

Entrepôt principal
├── Zone A - Matières premières
│   ├── A-01 Composants électroniques
│   └── A-02 Pièces structurelles
├── Zone B - Produits finis
│   ├── B-01 En attente d'expédition
│   └── B-02 Contrôlés
└── Zone C - Retours

Opérations de stock

Alertes de stock

Définissez des seuils minimaux de stock, avec alerte automatique de réapprovisionnement :

# Configurer une alerte de stock via un script Frappe
frappe.db.set_value("Item", "ITEM-001", "re_order_level", 100)
frappe.db.set_value("Item", "ITEM-001", "warehouse", "Entrepôt principal")

🤝 Module CRM et Ventes

Processus de vente

Prospect (Lead)
  ↓
Opportunité (Opportunity)
  ↓
Devis (Quotation)
  ↓
Commande de vente (Sales Order)
  ↓
Bon de livraison (Delivery Note)
  ↓
Facture de vente (Sales Invoice)
  ↓
Paiement (Payment Entry)

Points forts du CRM

• Gestion des prospects — suivi des sources, attribution commerciale, historique de suivi
• Entonnoir des opportunités — pipeline de vente visuel
• Modèles de devis — génération rapide de devis professionnels
• Portail client — les clients consultent eux-mêmes leurs commandes et factures
• Intégration e-mail — les e-mails entrants/sortants sont automatiquement associés aux clients

👥 Module Ressources Humaines (HRMS)

Gestion des employés

• Fiches employés (informations personnelles, contrats, contacts d'urgence)
• Organigramme (départements, postes, rapports hiérarchiques)
• Processus d'intégration et de départ

Pointage et congés

# Configuration des règles de pointage
attendance_policy = {
    "working_hours": "09:00-18:00",
    "late_entry_threshold": 15,  # minutes
    "early_exit_threshold": 15,
    "holiday_list": "2026-Jours fériés légaux"
}

# Types de congés
leave_types = [
    {"name": "Congés payés", "max_leaves": 10},
    {"name": "Congés maladie", "max_leaves": 5},
    {"name": "Congés personnels", "max_leaves": 0},  # nécessite approbation
    {"name": "Congés mariage", "max_leaves": 3},
]

Gestion des paies

• Structure salariale (salaire de base, performance, indemnités, retenues)
• Calcul automatique de l'impôt sur le revenu
• Génération et distribution des bulletins de paie
• Calcul des cotisations sociales

🏭 Module Fabrication (Manufacturing)

Nomenclature (BOM)

Produit : Enceinte connectée V2.0
├── Carte mère (x1)
│   ├── SoC principal (x1)
│   ├── Modules mémoire (x2)
│   └── Module WiFi (x1)
├── Composants audio (x1)
│   ├── Haut-parleurs (x2)
│   └── Carte amplificateur (x1)
├── Boîtier (x1)
└── Adaptateur secteur (x1)

Flux des ordres de fabrication

Plan de production (Production Plan)
  ↓
Ordre de fabrication (Work Order)
  ↓
Prélèvement de matières (Material Transfer)
  ↓
Fabrication (Manufacture)
  ↓
Contrôle qualité (Quality Inspection)
  ↓
Entrée en stock (Stock Entry)

Développement personnalisé en pratique

La grande force d'ERPNext réside dans son extensibilité. Basé sur le framework Frappe, vous pouvez répondre à des besoins spécifiques avec très peu de code.

Mise en place de l'environnement de développement

# 1. Créer un site de développement
bench new-site dev.localhost --force
bench use dev.localhost

# 2. Créer une application personnalisée
bench new-app my_custom_app

# Structure du répertoire :
# my_custom_app/
# ├── my_custom_app/
# │   ├── __init__.py
# │   ├── hooks.py          # Configuration des hooks de l'app
# │   ├── modules.txt        # Liste des modules
# │   ├── custom_doctype/    # DocTypes personnalisés
# │   └── api.py             # API personnalisées
# └── setup.py

DocType personnalisé (approche low-code)

Le DocType est le concept central de Frappe — il combine une table de base de données, un formulaire et une API.

Exemple : créer un module "Gestion de projets"

# Définir un DocType via du code Python
import frappe
from frappe.model.document import Document

class ProjectTask(Document):
    pass

# Registre dans hooks.py
# doc_events = {
#     "Project Task": {
#         "on_update": "my_custom_app.tasks.notify_assignee"
#     }
# }

Types de champs DocType

API personnalisées

# my_custom_app/api.py
import frappe
from frappe import _

@frappe.whitelist()
def get_project_summary(project_name):
    """Obtenir les informations résumées d'un projet"""
    project = frappe.get_doc("Project", project_name)

    tasks = frappe.get_all("Project Task",
        filters={"project": project_name},
        fields=["task_name", "status", "assigned_to", "deadline"]
    )

    return {
        "project_name": project.project_name,
        "status": project.status,
        "budget": project.budget,
        "tasks": tasks,
        "completion": project.percentage_complete
    }

# Méthode d'appel :
# GET /api/method/my_custom_app.api.get_project_summary?project_name=PRJ-001

Workflow personnalisé

# Définir un workflow d'approvisionnement
workflow = {
    "workflow_name": "Purchase Approval",
    "document_type": "Purchase Order",
    "states": [
        {"state": "Draft", "allow_edit": "Purchase Manager"},
        {"state": "Pending Approval", "allow_edit": "Purchase Manager"},
        {"state": "Approved", "allow_edit": "Director"},
        {"state": "Rejected", "allow_edit": "Director"},
    ],
    "transitions": [
        {"from": "Draft", "to": "Pending Approval", "action": "Submit", "allowed": "Purchase Manager"},
        {"from": "Pending Approval", "to": "Approved", "action": "Approve", "allowed": "Director"},
        {"from": "Pending Approval", "to": "Rejected", "action": "Reject", "allowed": "Director"},
    ]
}

Rapports personnalisés

# my_custom_app/reports/sales_summary.py
import frappe

def execute(filters=None):
    columns = [
        {"fieldname": "customer", "label": "客户", "fieldtype": "Link", "options": "Customer", "width": 200},
        {"fieldname": "total_sales", "label": "销售额", "fieldtype": "Currency", "width": 150},
        {"fieldname": "total_qty", "label": "数量", "fieldtype": "Int", "width": 100},
    ]

    conditions = ""
    if filters.get("from_date"):
        conditions += f" AND si.posting_date >= '{filters.from_date}'"
    if filters.get("to_date"):
        conditions += f" AND si.posting_date <= '{filters.to_date}'"

    data = frappe.db.sql(f"""
        SELECT
            si.customer,
            SUM(si.grand_total) as total_sales,
            SUM(si.total_qty) as total_qty
        FROM `tabSales Invoice` si
        WHERE si.docstatus = 1 {conditions}
        GROUP BY si.customer
        ORDER BY total_sales DESC
    """, as_dict=True)

    return columns, data

Personnalisation du frontend

ERPNext utilise Vue.js et des templates Jinja. Vous pouvez personnaliser :

// Script de formulaire personnalisé
frappe.ui.form.on('Sales Order', {
    refresh: function(frm) {
        // Ajouter un bouton personnalisé
        frm.add_custom_button('Exporter en PDF', function() {
            frappe.call({
                method: 'my_custom_app.api.export_pdf',
                args: { docname: frm.doc.name },
                callback: function(r) {
                    window.open(r.message.url);
                }
            });
        });
    },

    validate: function(frm) {
        // Validation personnalisée
        if (frm.doc.discount > 20) {
            frappe.throw('La remise ne peut pas dépasser 20 %');
        }
    }
});

Exploitation et optimisation

Sauvegarde et restauration

# Sauvegarder un site
bench --site erp.yourdomain.com backup

# Sauvegarder vers le cloud
bench --site erp.yourdomain.com backup --with-files

# Restaurer une sauvegarde
bench --site erp.yourdomain.com restore /path/to/database.sql.gz

# Sauvegarde planifiée (ajouter au crontab)
0 2 * * * cd /home/frappe/frappe-bench && bench backup-all-sites

Optimisation des performances

# 1. Activer le cache Redis (dans site_config.json)
{
    "cache_redis": "redis://localhost:6379"
}

# 2. Optimisation des index de base de données
# Ajouter des index sur les champs fréquemment interrogés
frappe.db.add_index("Sales Invoice", ["customer", "posting_date"])

# 3. Activer les processus multiples Gunicorn
# Dans la configuration de bench
bench config set-common-config -c gunicorn_workers 4

Monitoring et journaux

# Consulter les journaux bench
bench --site erp.yourdomain.com logs

# Consulter les requêtes lentes MariaDB
mysql -u root -e "SHOW VARIABLES LIKE 'slow_query_log%';"

# Surveiller les ressources du serveur
htop
iotop

FAQ sur ERPNext

Q1 : Pour quelle taille d'entreprise ERPNext est-il adapté ?

R : ERPNext convient des TPE aux entreprises de taille moyenne (1 à 500 employés) : - TPE (1-50 employés) : auto-hébergement gratuit, zéro coût de licence, mise en place rapide - PME (50-500 employés) : prise en charge multi-entreprises, multi-entrepôts, multi-devises pour des activités complexes - Grandes entreprises (500+ employés) : extensible via Frappe Cloud ou des clusters auto-hébergés

Q2 : ERPNext existe-t-il en version française ?

R : Oui, ERPNext est nativement disponible en français, y compris l'interface, les rapports et les modèles d'impression. Vous pouvez changer la langue dans les paramètres système. La communauté continue d'améliorer la localisation française, y compris le plan comptable français et la fiscalité.

Q3 : Quelle est la différence entre ERPNext et Odoo ?

R : Les différences majeures : - Degré d'open source : ERPNext est 100 % open source (GPL), Odoo Community n'inclut pas les modules finance clés - Tarification : ERPNext est entièrement gratuit, Odoo Enterprise est facturé par utilisateur - Développement personnalisé : Le framework Frappe d'ERPNext offre de meilleures capacités low-code qu'Odoo qui nécessite plus de code - Écosystème francophone : la communauté ERPNext francophone est active, Odoo dispose de ressources francophones plus matures

Q4 : De quel serveur ai-je besoin pour auto-héberger ERPNext ?

R : Configuration minimale : - 2 cœurs CPU + 4 Go RAM + 20 Go de stockage — pour les tests et les petites équipes (<20 personnes) - 4 cœurs CPU + 8 Go RAM + 50 Go de stockage — pour les PME (20-100 personnes) - 8 cœurs CPU + 16 Go RAM + 100 Go+ SSD — pour les grandes entreprises (100+ personnes)

Il est recommandé d'utiliser du stockage SSD pour améliorer les performances de la base de données.

Q5 : ERPNext peut-il s'intégrer avec d'autres systèmes ?

R : Oui. ERPNext fournit une API REST et un support Webhook, permettant l'intégration avec : - Plateformes e-commerce : Shopify, WooCommerce, PrestaShop - Passerelles de paiement : PayPal, Stripe, Mangopay - Systèmes logistiques : La Poste, Chronopost, FedEx - Systèmes tiers : connectez n'importe quel système externe via l'API

# Exemple d'API REST ERPNext
import requests

# Récupérer la liste des clients
response = requests.get(
    "https://erp.yourdomain.com/api/resource/Customer",
    headers={"Authorization": "token api_key:api_secret"}
)
customers = response.json()

# Créer une commande de vente
response = requests.post(
    "https://erp.yourdomain.com/api/resource/Sales Order",
    headers={"Authorization": "token api_key:api_secret", "Content-Type": "application/json"},
    json={"customer": "CUST-001", "items": [{"item_code": "ITEM-001", "qty": 10}]}
)

Conclusion

ERPNext est l'une des solutions ERP open source les plus matures et les plus complètes disponibles aujourd'hui. Non seulement il répond aux besoins de gestion quotidienne des PME, mais grâce à la puissance du framework Frappe, il permet également un développement personnalisé hautement adaptable.

Parcours de prise en main rapide : 1. Déploiement Docker en un clic (5 minutes) 2. Configuration de l'entreprise, des utilisateurs et des données de base 3. Commencer à utiliser le module finance ou CRM 4. Activer progressivement les autres modules selon vos besoins 5. Développement personnalisé si nécessaire

Que vous soyez une startup en pleine croissance ou une entreprise traditionnelle en pleine transformation numérique, ERPNext mérite votre attention. 100 % gratuit, entièrement open source, communauté active — c'est le cœur de la compétitivité d'ERPNext.

Visitez le site officiel ERPNext ou le répository GitHub pour en savoir plus.