Distribuer une application Django à des utilisateurs finaux peut être complexe. Ce guide montre comment transformer votre projet en un logiciel natif (.msi) avec une icône personnalisée et une gestion autonome des fichiers statiques.
Qu'est-ce que Tauri ?
"Optimized, secure, and frontend-independent application toolkit."
Tauri est le nouveau standard pour la création d'applications de bureau légères et ultra-performantes. Contrairement à Electron qui embarque tout un navigateur (Chromium), Tauri utilise le moteur de rendu natif de votre système d'exploitation (WebView2 sur Windows, WebKit sur macOS). Le cœur de l'application est propulsé par Rust, un langage réputé pour sa sécurité et sa vitesse fulgurante.
Pourquoi Tauri est le compagnon idéal de Django ?
Si vous cherchez à distribuer votre application Django avec un minimum d'empreinte mémoire et une sécurité maximale, Tauri est le choix logique :
- 🚀 Poids Plume : Une application Tauri pèse souvent moins de 10 Mo, contre plus de 150 Mo pour une application Electron équivalente.
- 🚀 Performance CPU/RAM : En utilisant la WebView du système, Tauri consomme jusqu'à 50% de RAM en moins. Votre application est fluide, même sur de petites configurations.
- 🚀 Sécurité Native : Le "bridge" entre Rust et votre interface web est conçu pour empêcher les injections de code et garantir l'intégrité de vos données.
- 🚀 Installeurs natifs : Tauri génère des fichiers .msi (Windows), .dmg (Mac) et .deb (Linux) parfaitement intégrés au système, avec des mises à jour automatiques simplifiées.
💡 Dans ce guide, nous exploitons la puissance du "Sidecar" de Tauri : une fonctionnalité qui permet d'embarquer et de piloter votre serveur Django (compilé en binaire) directement depuis le cœur en Rust.
1. La Structure du Projet
├── backend-django/ (Projet Django)
├── src-tauri/
│ ├── binaries/ (Exécutable Python final)
│ └── tauri.conf.json
└── logo.png
2. Configurer WhiteNoise pour les fichiers statiques
En mode Desktop, vous n'avez pas de serveur Nginx pour servir vos images, CSS et JS. WhiteNoise permet à Django de servir ses propres fichiers statiques de manière ultra-performante.
Installation et Configuration
# Installez WhiteNoise
pip install whitenoise
Modifiez votre settings.py pour activer le middleware :
# backend-django/settings.py
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'whitenoise.middleware.WhiteNoiseMiddleware', # Doit être juste après SecurityMiddleware
'django.contrib.sessions.middleware.SessionMiddleware',
# ...
]
# Configuration du stockage statique
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
3. Gestion de la persistance (%APPDATA%)
Le dossier d'installation étant verrouillé, nous déplaçons la base de données SQLite dans le dossier utilisateur Windows.
Localisation de la DB
import os
if os.name == 'nt': # Windows
APP_DATA_PATH = os.path.join(os.environ['APPDATA'], 'MaSuperApp')
else:
APP_DATA_PATH = os.path.expanduser('~/.masuperapp')
os.makedirs(APP_DATA_PATH, exist_ok=True)
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(APP_DATA_PATH, 'db.sqlite3'),
}
}
4. Création du binaire Sidecar
Le script Launcher
Créez launcher.py pour automatiser les migrations et le ramassage des fichiers statiques avant le lancement :
import os, sys
from django.core.management import execute_from_command_line
if __name__ == "__main__":
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mon_projet.settings')
# Préparation automatique au lancement
execute_from_command_line(['manage.py', 'collectstatic', '--noinput'])
execute_from_command_line(['manage.py', 'migrate', '--noinput'])
# Lancement du serveur
execute_from_command_line(['manage.py', 'runserver', '127.0.0.1:8000', '--noreload'])
Compilez avec PyInstaller :
pyinstaller --onefile --name django-backend-x86_64-pc-windows-msvc launcher.py
5. Orchestration Rust et Build Final
Dans src-tauri/src/main.rs, nous démarrons le serveur Python dès l'ouverture de l'application.
use tauri::api::process::Command;
fn main() {
tauri::Builder::default()
.setup(|app| {
let (mut rx, _child) = Command::new_sidecar("django-backend")
.expect("Erreur sidecar")
.spawn()
.expect("Echec du lancement Django");
Ok(())
})
.run(tauri::generate_context!())
.expect("Erreur Tauri");
}
npm run tauri icon ./logo.png avant le build final.6. Lancer le Build
npm run tauri build
Résultat Final
Votre application est maintenant compilée dans un fichier .msi. Grâce à WhiteNoise, vos interfaces CSS/JS s'affichent parfaitement, et grâce à la gestion du dossier AppData, vos utilisateurs ne perdront jamais leurs données lors d'une mise à jour.
