migrate to MariaDB and reorganize documentation and scripts

.env.example

@@ -6,7 +6,16 @@ SECRET_KEY=votre-cle-secrete-ici
 DEBUG=True
 
 # Base de données
-DATABASE_NAME=db.sqlite3
+# Pour SQLite (développement local)
+# DATABASE_NAME=db.sqlite3
+
+# Pour MariaDB/MySQL (production)
+DB_ENGINE=mysql
+DB_NAME=duhaz_blog
+DB_USER=duhaz_user
+DB_PASSWORD=votre_mot_de_passe
+DB_HOST=mariadb  # Nom du conteneur Docker
+DB_PORT=3306
 
 # Hôtes autorisés (séparés par des virgules)
 ALLOWED_HOSTS=localhost,127.0.0.1

docs/migration/CHECKLIST_MIGRATION.md

@@ -0,0 +1,238 @@
+# ✅ Checklist de migration SQLite → MariaDB
+
+## Avant de commencer
+
+- [ ] J'ai un backup de ma base SQLite actuelle (`db.sqlite3`)
+- [ ] Le conteneur MariaDB tourne sur mon Raspberry Pi
+- [ ] Je peux accéder au Raspberry Pi (SSH ou accès physique)
+- [ ] J'ai noté l'IP du Raspberry Pi : `_______________`
+
+## Étape 1 : Configuration de MariaDB (sur le RPI)
+
+- [ ] Connecté au conteneur MariaDB
+  ```bash
+  docker exec -it mariadb mysql -u root -p
+  ```
+
+- [ ] Base de données créée
+  ```sql
+  CREATE DATABASE IF NOT EXISTS duhaz_blog CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+  ```
+
+- [ ] Utilisateur créé avec un mot de passe fort
+  ```sql
+  CREATE USER IF NOT EXISTS 'duhaz_user'@'%' IDENTIFIED BY 'MON_MOT_DE_PASSE';
+  ```
+
+- [ ] Privilèges accordés
+  ```sql
+  GRANT ALL PRIVILEGES ON duhaz_blog.* TO 'duhaz_user'@'%';
+  FLUSH PRIVILEGES;
+  ```
+
+- [ ] Port 3306 exposé (si connexion depuis Mac)
+  ```bash
+  docker port mariadb
+  # Doit afficher : 3306/tcp -> 0.0.0.0:3306
+  ```
+
+## Étape 2 : Installation des dépendances (sur votre Mac)
+
+- [ ] Navigué vers le projet
+  ```bash
+  cd /Users/duhaz/projets/blog-duhaz
+  ```
+
+- [ ] Dépendances installées
+  ```bash
+  pip install -r requirements.txt
+  ```
+
+- [ ] `mysqlclient` installé correctement
+  ```bash
+  python -c "import MySQLdb; print('OK')"
+  ```
+
+## Étape 3 : Configuration du fichier .env
+
+- [ ] Fichier `.env` modifié avec :
+  ```env
+  DB_ENGINE=mysql
+  DB_NAME=duhaz_blog
+  DB_USER=duhaz_user
+  DB_PASSWORD=mon_mot_de_passe
+  DB_HOST=_______________  # IP du RPI ou "mariadb"
+  DB_PORT=3306
+  ```
+
+- [ ] Mot de passe saisi correctement (attention aux espaces)
+
+- [ ] Host configuré selon le contexte :
+  - `mariadb` si Django tourne sur le même RPI
+  - `192.168.x.x` (IP du RPI) si Django tourne sur Mac
+
+## Étape 4 : Test de connexion
+
+- [ ] Test réseau réussi
+  ```bash
+  telnet IP_DU_RPI 3306
+  # Doit se connecter
+  ```
+
+- [ ] Test de connexion Python réussi
+  ```bash
+  python scripts/test_mariadb_connection.py
+  # Tous les tests doivent passer ✅
+  ```
+
+## Étape 5 : Migration des données
+
+- [ ] Script de migration exécuté
+  ```bash
+  python scripts/migrate_to_mariadb.py
+  ```
+
+- [ ] Export SQLite réussi
+  ```
+  ✅ Données exportées vers backup/sqlite_data.json
+  ```
+
+- [ ] Fichier `.env` vérifié (DB_ENGINE=mysql)
+
+- [ ] Import MariaDB réussi
+  ```
+  ✅ Données importées avec succès!
+  ```
+
+- [ ] Vérification affichée
+  ```
+  👥 Utilisateurs: X
+  📝 Articles: Y
+  ```
+
+## Étape 6 : Tests post-migration
+
+- [ ] Serveur de développement lancé
+  ```bash
+  python manage.py runserver
+  ```
+
+- [ ] Page d'accueil accessible (http://localhost:8000)
+
+- [ ] Articles visibles sur le blog
+
+- [ ] Connexion admin fonctionnelle (http://localhost:8000/admin)
+
+- [ ] Création d'un nouvel article de test
+
+- [ ] Modification d'un article existant
+
+- [ ] Médias/images toujours accessibles
+
+## Étape 7 : Vérifications de production
+
+Si vous déployez sur le RPI :
+
+- [ ] Variables d'environnement de production configurées
+  ```env
+  DEBUG=False
+  ALLOWED_HOSTS=duhaz.fr,www.duhaz.fr
+  ```
+
+- [ ] Migrations appliquées sur la production
+  ```bash
+  python manage.py migrate
+  ```
+
+- [ ] Static files collectés
+  ```bash
+  python manage.py collectstatic
+  ```
+
+- [ ] Application redémarrée
+
+- [ ] Site web accessible publiquement
+
+- [ ] HTTPS fonctionnel
+
+## Étape 8 : Nettoyage (après confirmation)
+
+⚠️ **NE FAITES CECI QU'APRÈS AVOIR CONFIRMÉ QUE TOUT FONCTIONNE** ⚠️
+
+- [ ] ✅ Tout fonctionne parfaitement depuis au moins 24h
+
+- [ ] Backup final de la base SQLite
+  ```bash
+  cp db.sqlite3 backup/db.sqlite3.final_backup_$(date +%Y%m%d)
+  ```
+
+- [ ] Backup du JSON
+  ```bash
+  # Le fichier backup/sqlite_data.json est déjà créé
+  ```
+
+- [ ] (Optionnel) Suppression de `db.sqlite3` du dossier projet
+  ```bash
+  # Gardez-le quelques semaines par sécurité !
+  mv db.sqlite3 backup/
+  ```
+
+## Backups à conserver
+
+Gardez ces fichiers en sécurité :
+
+- [ ] `backup/sqlite_data.json` - Export JSON complet
+- [ ] `backup/db.sqlite3.final_backup_YYYYMMDD` - Base SQLite finale
+- [ ] Backup MariaDB régulier configuré
+  ```bash
+  docker exec mariadb mysqldump -u root -p duhaz_blog > backup_$(date +%Y%m%d).sql
+  ```
+
+## En cas de problème
+
+### La migration a échoué
+
+1. ❌ Ne paniquez pas !
+2. ✅ Votre `db.sqlite3` est intact
+3. ✅ Changez `DB_ENGINE` dans `.env` pour revenir à SQLite
+4. ✅ Relancez l'application avec SQLite
+5. 🔍 Consultez `docs/MIGRATION_MARIADB.md` pour le dépannage
+
+### Performances lentes
+
+- [ ] Index vérifiés sur les colonnes fréquemment requêtées
+- [ ] Configuration MariaDB optimisée (my.cnf)
+- [ ] Connexions pooling configurées si nécessaire
+
+### Erreurs de charset
+
+- [ ] Base de données en UTF8MB4
+  ```sql
+  ALTER DATABASE duhaz_blog CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+  ```
+
+- [ ] Tables vérifiées
+  ```sql
+  SHOW TABLE STATUS LIKE '%';
+  ```
+
+## Notes importantes
+
+- 🔒 **Sécurité** : Utilisez des mots de passe forts
+- 💾 **Backups** : Automatisez les sauvegardes MariaDB
+- 🔍 **Monitoring** : Surveillez les logs MariaDB
+- 📊 **Performance** : MariaDB est généralement plus rapide que SQLite pour les sites avec du trafic
+
+## Support
+
+- 📚 Documentation complète : `docs/MIGRATION_MARIADB.md`
+- 🌐 Configuration réseau : `docs/CONFIGURATION_RESEAU_MARIADB.md`
+- ⚡ Aide-mémoire rapide : `MIGRATION_MARIADB_RAPIDE.md`
+
+---
+
+**Date de migration** : _______________
+
+**Signature** : _______________
+
+**Durée totale** : _______________ minutes

docs/migration/CONFIGURATION_RESEAU_MARIADB.md

@@ -0,0 +1,248 @@
+# Configuration réseau pour accéder à MariaDB sur le Raspberry Pi
+
+## Scénarios de connexion
+
+### Scénario 1 : Application Django sur le même RPI que MariaDB
+
+Si votre application Django tourne **dans un autre conteneur Docker** sur le même Raspberry Pi :
+
+```env
+# .env
+DB_HOST=mariadb  # Nom du conteneur (résolution DNS Docker)
+DB_PORT=3306
+```
+
+✅ C'est le cas pour la production sur le RPI
+
+### Scénario 2 : Développement sur Mac, MariaDB sur RPI
+
+Si vous développez sur votre **Mac** et que MariaDB est sur le **Raspberry Pi** :
+
+```env
+# .env
+DB_HOST=192.168.x.x  # IP du Raspberry Pi sur le réseau local
+DB_PORT=3306
+```
+
+⚠️ Le port 3306 doit être exposé sur le réseau (pas seulement au réseau Docker interne)
+
+## Configuration du conteneur MariaDB sur le RPI
+
+### Vérifier si le port est exposé
+
+```bash
+# Sur le Raspberry Pi
+docker port mariadb
+```
+
+Si vous voyez `3306/tcp -> 0.0.0.0:3306`, le port est bien exposé. ✅
+
+Si vous ne voyez rien, le port n'est pas exposé. ❌
+
+### Exposer le port si nécessaire
+
+Si le conteneur a été créé sans exposer le port, vous avez deux options :
+
+#### Option 1 : Recréer le conteneur (recommandé)
+
+```bash
+# Sauvegarder d'abord les données !
+docker exec mariadb mysqldump -u root -p --all-databases > backup_all.sql
+
+# Arrêter et supprimer le conteneur
+docker stop mariadb
+docker rm mariadb
+
+# Recréer avec le port exposé
+docker run -d \
+  --name mariadb \
+  -p 3306:3306 \
+  -e MYSQL_ROOT_PASSWORD=votre_mot_de_passe \
+  -v mariadb_data:/var/lib/mysql \
+  mariadb:latest
+
+# Restaurer les données
+docker exec -i mariadb mysql -u root -p < backup_all.sql
+```
+
+#### Option 2 : Utiliser un tunnel SSH (temporaire pour dev)
+
+Si vous ne voulez pas modifier le conteneur :
+
+```bash
+# Sur votre Mac
+ssh -L 3306:localhost:3306 user@raspberry-pi-ip
+```
+
+Puis dans votre `.env` :
+
+```env
+DB_HOST=127.0.0.1  # Se connecte via le tunnel SSH
+DB_PORT=3306
+```
+
+## Trouver l'IP du Raspberry Pi
+
+### Sur le Raspberry Pi
+
+```bash
+hostname -I
+# Exemple de sortie : 192.168.1.100 fe80::xxxx
+# Utilisez la première IP (IPv4)
+```
+
+Ou :
+
+```bash
+ip addr show | grep "inet " | grep -v 127.0.0.1
+```
+
+### Depuis votre Mac
+
+```bash
+# Si vous connaissez le hostname du RPI
+ping raspberrypi.local
+
+# Scanner le réseau (nécessite nmap)
+nmap -sn 192.168.1.0/24 | grep -B 2 "Raspberry"
+```
+
+## Tester la connexion
+
+### Depuis votre Mac
+
+```bash
+# Test 1 : Port ouvert ?
+telnet 192.168.1.100 3306
+# Si ça se connecte : ✅
+# Si "Connection refused" : ❌ Port non exposé ou firewall
+
+# Test 2 : Connexion MySQL
+mysql -h 192.168.1.100 -u duhaz_user -p duhaz_blog
+# Si ça fonctionne : ✅
+```
+
+### Test avec Python
+
+```python
+# test_connection.py
+import MySQLdb
+
+try:
+    conn = MySQLdb.connect(
+        host='192.168.1.100',  # IP du RPI
+        user='duhaz_user',
+        passwd='votre_mot_de_passe',
+        db='duhaz_blog',
+        port=3306
+    )
+    print("✅ Connexion réussie!")
+    conn.close()
+except Exception as e:
+    print(f"❌ Erreur: {e}")
+```
+
+## Sécurité
+
+### Pour la production
+
+Ne laissez PAS le port 3306 ouvert sur Internet ! Utilisez plutôt :
+
+1. **Réseau Docker interne** : Les conteneurs communiquent entre eux sans exposer le port
+2. **Reverse proxy** : Seul le port 80/443 est exposé
+3. **VPN** : Pour accéder à distance de manière sécurisée
+
+### Pour le développement local
+
+C'est OK d'exposer le port sur le réseau local (192.168.x.x) si :
+- Votre réseau local est sûr (chez vous)
+- Vous utilisez un mot de passe fort
+- Le pare-feu du RPI bloque les connexions externes
+
+## Configuration recommandée
+
+### Production (Django + MariaDB sur le même RPI)
+
+```yaml
+# docker-compose.yml
+version: '3.8'
+services:
+  mariadb:
+    image: mariadb:latest
+    environment:
+      MYSQL_ROOT_PASSWORD: password_fort
+      MYSQL_DATABASE: duhaz_blog
+      MYSQL_USER: duhaz_user
+      MYSQL_PASSWORD: password_fort
+    volumes:
+      - mariadb_data:/var/lib/mysql
+    networks:
+      - blog_network
+    # PAS de ports: exposés !
+
+  django:
+    build: .
+    environment:
+      DB_HOST: mariadb  # Nom du service
+      DB_PORT: 3306
+    networks:
+      - blog_network
+    ports:
+      - "8000:8000"
+
+volumes:
+  mariadb_data:
+
+networks:
+  blog_network:
+```
+
+### Développement (Mac → RPI)
+
+```bash
+# Sur le RPI : exposer le port
+docker run -d --name mariadb -p 3306:3306 ...
+
+# Sur le Mac : .env
+DB_HOST=192.168.1.100
+DB_PORT=3306
+```
+
+## Dépannage
+
+### "Can't connect to MySQL server"
+
+1. ✅ Vérifiez que le conteneur tourne : `docker ps | grep mariadb`
+2. ✅ Vérifiez que le port est exposé : `docker port mariadb`
+3. ✅ Testez la connexion réseau : `telnet IP 3306`
+4. ✅ Vérifiez le pare-feu du RPI : `sudo ufw status`
+
+### "Access denied for user"
+
+1. ✅ Vérifiez les identifiants dans `.env`
+2. ✅ Vérifiez que l'utilisateur peut se connecter depuis n'importe où :
+   ```sql
+   SELECT User, Host FROM mysql.user WHERE User = 'duhaz_user';
+   -- Host doit être '%' ou votre IP
+   ```
+
+### "Host 'xxx.xxx.xxx.xxx' is not allowed to connect"
+
+L'utilisateur n'a pas le droit de se connecter depuis votre IP :
+
+```sql
+-- Sur le RPI
+docker exec -it mariadb mysql -u root -p
+
+GRANT ALL PRIVILEGES ON duhaz_blog.* TO 'duhaz_user'@'192.168.1.%';
+FLUSH PRIVILEGES;
+```
+
+## Résumé des configurations
+
+| Situation | DB_HOST | Port exposé ? |
+|-----------|---------|---------------|
+| Production (Docker) | `mariadb` | Non |
+| Dev local (Mac → RPI) | `192.168.x.x` | Oui |
+| Dev avec tunnel SSH | `127.0.0.1` | Non (via SSH) |
+| RPI local (même machine) | `localhost` | Oui |

docs/migration/GUIDE_MIGRATION_MARIADB_COMPLET.md

@@ -0,0 +1,539 @@
+# 🚀 Guide de Migration vers MariaDB - Version Complète
+
+## 📋 Vue d'ensemble
+
+Ce guide vous accompagne pour migrer votre blog Django de SQLite vers MariaDB sur votre Raspberry Pi.
+
+### Prérequis
+- ✅ Serveur MariaDB dans Docker sur le RPI (conteneur nommé `mariadb`)
+- ✅ Accès réseau du Mac vers le RPI
+- ✅ Python 3.x installé
+- ✅ Fichier `.env` configuré
+
+---
+
+## 🎯 Étape 1 : Vérifications préliminaires
+
+### 1.1 Vérifier l'environnement
+
+```bash
+# Rendre le script exécutable
+chmod +x scripts/pre_migration_check.sh
+
+# Lancer les vérifications
+./scripts/pre_migration_check.sh
+```
+
+Ce script vérifie :
+- ✅ Python et dépendances installées
+- ✅ Configuration du fichier `.env`
+- ✅ Connexion réseau vers MariaDB
+- ✅ Présence de la base SQLite source
+
+### 1.2 Installer les dépendances manquantes
+
+Si des dépendances manquent :
+
+```bash
+pip3 install -r requirements.txt
+```
+
+**Important**: `mysqlclient` nécessite des outils de compilation :
+
+**Sur macOS :**
+```bash
+brew install mysql-client pkg-config
+export PKG_CONFIG_PATH="/opt/homebrew/opt/mysql-client/lib/pkgconfig"
+pip3 install mysqlclient
+```
+
+---
+
+## 🔧 Étape 2 : Configuration du serveur MariaDB
+
+### 2.1 Vérifier que le conteneur Docker est démarré
+
+Sur votre **Raspberry Pi** :
+
+```bash
+# Vérifier si le conteneur tourne
+docker ps | grep mariadb
+
+# Si non démarré, le démarrer
+docker start mariadb
+
+# Voir les logs
+docker logs mariadb
+```
+
+### 2.2 Vérifier l'exposition du port
+
+```bash
+# Sur le RPI
+docker port mariadb
+# Devrait afficher : 3306/tcp -> 0.0.0.0:3306
+```
+
+Si le port n'est pas exposé, recréez le conteneur :
+
+```bash
+docker run -d \
+  --name mariadb \
+  -p 3306:3306 \
+  -e MYSQL_ROOT_PASSWORD=votre_mot_de_passe_root \
+  -v mariadb_data:/var/lib/mysql \
+  --restart unless-stopped \
+  mariadb:latest
+```
+
+### 2.3 Créer la base de données et l'utilisateur
+
+Sur le **Raspberry Pi** :
+
+```bash
+# Se connecter à MariaDB
+docker exec -it mariadb mysql -u root -p
+```
+
+Puis dans le shell MySQL :
+
+```sql
+-- Créer la base de données
+CREATE DATABASE IF NOT EXISTS duhaz_blog 
+  CHARACTER SET utf8mb4 
+  COLLATE utf8mb4_unicode_ci;
+
+-- Créer l'utilisateur
+CREATE USER IF NOT EXISTS 'duhaz_user'@'%' 
+  IDENTIFIED BY 'votre_mot_de_passe_securise';
+
+-- Donner tous les droits sur la base
+GRANT ALL PRIVILEGES ON duhaz_blog.* TO 'duhaz_user'@'%';
+
+-- Appliquer les changements
+FLUSH PRIVILEGES;
+
+-- Vérifier
+SHOW DATABASES;
+SELECT User, Host FROM mysql.user WHERE User = 'duhaz_user';
+
+-- Quitter
+EXIT;
+```
+
+**Note**: `'duhaz_user'@'%'` permet les connexions depuis n'importe quelle IP. Pour plus de sécurité, remplacez `%` par l'IP de votre Mac.
+
+---
+
+## 🌐 Étape 3 : Configuration réseau
+
+### 3.1 Trouver l'IP de votre Raspberry Pi
+
+Sur le **RPI** :
+
+```bash
+hostname -I
+# Exemple de résultat : 192.168.1.100
+```
+
+### 3.2 Tester la connexion réseau
+
+Depuis votre **Mac** :
+
+```bash
+# Test de ping
+ping 192.168.1.100
+
+# Test du port MariaDB
+nc -zv 192.168.1.100 3306
+# ou
+telnet 192.168.1.100 3306
+```
+
+Si le port n'est pas accessible, vérifiez :
+- Le pare-feu du RPI : `sudo ufw status`
+- Le conteneur Docker expose bien le port
+- Votre réseau local autorise les connexions
+
+---
+
+## ⚙️ Étape 4 : Configuration du fichier .env
+
+### 4.1 Éditer le fichier .env
+
+Deux options pour `DB_HOST` :
+
+**Option A : Utiliser le nom du conteneur** (si votre Mac fait partie du réseau Docker)
+```env
+DB_ENGINE=mysql
+DB_NAME=duhaz_blog
+DB_USER=duhaz_user
+DB_PASSWORD=votre_mot_de_passe_securise
+DB_HOST=mariadb
+DB_PORT=3306
+```
+
+**Option B : Utiliser l'IP du RPI** (recommandé pour développement depuis un autre machine)
+```env
+DB_ENGINE=mysql
+DB_NAME=duhaz_blog
+DB_USER=duhaz_user
+DB_PASSWORD=votre_mot_de_passe_securise
+DB_HOST=192.168.1.100
+DB_PORT=3306
+```
+
+### 4.2 Sécurité du mot de passe
+
+⚠️ **Important** : N'utilisez JAMAIS de mots de passe simples en production !
+
+Générer un mot de passe fort :
+```bash
+openssl rand -base64 32
+```
+
+---
+
+## 🧪 Étape 5 : Test de connexion
+
+### 5.1 Test direct avec Python
+
+```bash
+python3 scripts/test_mariadb_connection.py
+```
+
+Ce script teste :
+1. Import du module MySQLdb
+2. Connexion directe à MariaDB
+3. Connexion via Django
+
+### 5.2 Interpréter les résultats
+
+**✅ Succès** :
+```
+✅ Tous les tests sont passés!
+```
+
+**❌ Échec** - Erreurs courantes :
+
+| Erreur | Solution |
+|--------|----------|
+| `ModuleNotFoundError: No module named 'MySQLdb'` | `pip3 install mysqlclient` |
+| `Can't connect to MySQL server` | Vérifier que MariaDB est démarré et accessible |
+| `Access denied for user` | Vérifier DB_USER et DB_PASSWORD dans .env |
+| `Unknown database` | Créer la base avec les commandes SQL ci-dessus |
+
+---
+
+## 📦 Étape 6 : Sauvegarde des données SQLite
+
+### 6.1 Sauvegarde automatique
+
+Le script de migration crée automatiquement un backup, mais vous pouvez aussi le faire manuellement :
+
+```bash
+# Créer le dossier de backup
+mkdir -p backup
+
+# Copier la base SQLite
+cp db.sqlite3 backup/db.sqlite3.backup
+
+# Export JSON des données
+python3 manage.py dumpdata \
+  --natural-foreign \
+  --natural-primary \
+  --exclude=contenttypes \
+  --exclude=auth.permission \
+  --indent=2 \
+  --output=backup/sqlite_data.json
+```
+
+### 6.2 Vérifier le backup
+
+```bash
+# Taille du fichier
+ls -lh backup/
+
+# Nombre d'objets dans le JSON
+grep -c '"model":' backup/sqlite_data.json
+```
+
+---
+
+## 🚀 Étape 7 : Migration des données
+
+### 7.1 Lancer la migration automatique
+
+```bash
+python3 scripts/migrate_to_mariadb.py
+```
+
+Le script effectue :
+1. **Export** des données depuis SQLite
+2. **Pause** pour que vous modifiiez le .env vers MariaDB
+3. **Import** des données dans MariaDB
+4. **Vérification** du nombre d'enregistrements
+
+### 7.2 Processus étape par étape
+
+Le script vous demandera :
+
+```
+⚠️ IMPORTANT: Maintenant, modifiez votre fichier .env
+Changez DB_ENGINE de 'sqlite3' à 'mysql'
+Appuyez sur Entrée quand c'est fait...
+```
+
+À ce moment :
+1. Éditez le fichier `.env`
+2. Changez `DB_ENGINE=sqlite3` vers `DB_ENGINE=mysql`
+3. Appuyez sur Entrée dans le terminal
+
+### 7.3 Migration manuelle (si nécessaire)
+
+Si vous préférez contrôler chaque étape :
+
+```bash
+# 1. Exporter depuis SQLite (avec DB_ENGINE=sqlite3)
+python3 manage.py dumpdata \
+  --natural-foreign \
+  --natural-primary \
+  --exclude=contenttypes \
+  --exclude=auth.permission \
+  --indent=2 \
+  --output=backup/manual_export.json
+
+# 2. Modifier le .env pour passer à MariaDB
+# DB_ENGINE=mysql
+
+# 3. Créer les tables dans MariaDB
+python3 manage.py migrate --run-syncdb
+
+# 4. Importer les données
+python3 manage.py loaddata backup/manual_export.json
+```
+
+---
+
+## ✅ Étape 8 : Vérification post-migration
+
+### 8.1 Vérifier les données
+
+```bash
+# Lancer le shell Django
+python3 manage.py shell
+```
+
+Dans le shell Python :
+
+```python
+from django.contrib.auth.models import User
+from blog.models import Article
+
+# Compter les utilisateurs
+print(f"Utilisateurs: {User.objects.count()}")
+
+# Compter les articles
+print(f"Articles: {Article.objects.count()}")
+
+# Afficher le premier article
+article = Article.objects.first()
+if article:
+    print(f"Premier article: {article.title}")
+```
+
+### 8.2 Tester l'interface admin
+
+```bash
+# Démarrer le serveur
+python3 manage.py runserver
+```
+
+Accédez à : http://127.0.0.1:8000/admin/
+
+Vérifiez :
+- ✅ Connexion avec votre compte admin
+- ✅ Liste des articles visible
+- ✅ Modification d'un article fonctionne
+- ✅ Création d'un nouvel article fonctionne
+
+### 8.3 Tester le site public
+
+Accédez à : http://127.0.0.1:8000/
+
+Vérifiez :
+- ✅ Les articles s'affichent
+- ✅ Les images sont visibles
+- ✅ Les liens fonctionnent
+- ✅ La recherche fonctionne
+
+---
+
+## 🔧 Dépannage
+
+### Problème : Can't connect to MySQL server
+
+**Cause** : Le serveur n'est pas accessible
+
+**Solutions** :
+```bash
+# 1. Vérifier que le conteneur tourne
+docker ps | grep mariadb
+
+# 2. Voir les logs
+docker logs mariadb
+
+# 3. Tester la connexion réseau
+telnet 192.168.1.100 3306
+
+# 4. Vérifier le pare-feu
+sudo ufw status
+```
+
+### Problème : Access denied for user
+
+**Cause** : Identifiants incorrects
+
+**Solutions** :
+```bash
+# Vérifier les variables dans .env
+cat .env | grep DB_
+
+# Tester la connexion directement
+docker exec -it mariadb mysql -u duhaz_user -p
+```
+
+### Problème : Unknown database 'duhaz_blog'
+
+**Cause** : La base n'existe pas
+
+**Solution** :
+```bash
+# Se connecter en root
+docker exec -it mariadb mysql -u root -p
+
+# Créer la base
+CREATE DATABASE duhaz_blog CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+```
+
+### Problème : Table already exists
+
+**Cause** : Les migrations ont déjà été appliquées
+
+**Solution** :
+```bash
+# Supprimer toutes les tables et recommencer
+docker exec -it mariadb mysql -u root -p
+
+DROP DATABASE duhaz_blog;
+CREATE DATABASE duhaz_blog CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+# Relancer la migration
+python3 scripts/migrate_to_mariadb.py
+```
+
+### Problème : ImportError: No module named 'MySQLdb'
+
+**Cause** : mysqlclient n'est pas installé
+
+**Solution macOS** :
+```bash
+# Installer les dépendances système
+brew install mysql-client pkg-config
+
+# Configurer PKG_CONFIG_PATH
+export PKG_CONFIG_PATH="/opt/homebrew/opt/mysql-client/lib/pkgconfig"
+
+# Installer mysqlclient
+pip3 install mysqlclient
+```
+
+---
+
+## 📊 Comparaison SQLite vs MariaDB
+
+| Caractéristique | SQLite | MariaDB |
+|----------------|--------|---------|
+| **Performance lecture** | Excellente | Très bonne |
+| **Performance écriture** | Bonne | Excellente |
+| **Concurrence** | Limitée | Excellente |
+| **Backup** | Copie de fichier | mysqldump |
+| **Taille max** | ~140 To | Pratiquement illimitée |
+| **Adapté pour** | Dev, petits sites | Production, sites moyens/grands |
+
+---
+
+## 🔒 Sécurité en production
+
+Avant de déployer en production, modifiez `.env` :
+
+```env
+# Désactiver le mode debug
+DEBUG=False
+
+# Limiter les hôtes autorisés
+ALLOWED_HOSTS=duhaz.fr,www.duhaz.fr
+
+# Utiliser un mot de passe fort
+DB_PASSWORD=<mot_de_passe_généré_par_openssl>
+```
+
+Et dans `settings.py`, décommentez :
+
+```python
+SECURE_SSL_REDIRECT = True
+SESSION_COOKIE_SECURE = True
+CSRF_COOKIE_SECURE = True
+SECURE_BROWSER_XSS_FILTER = True
+SECURE_CONTENT_TYPE_NOSNIFF = True
+X_FRAME_OPTIONS = 'DENY'
+```
+
+---
+
+## 📚 Ressources
+
+### Documentation officielle
+- [Django Database Configuration](https://docs.djangoproject.com/en/5.1/ref/databases/)
+- [MariaDB Knowledge Base](https://mariadb.com/kb/en/)
+- [mysqlclient Documentation](https://mysqlclient.readthedocs.io/)
+
+### Fichiers du projet
+- `scripts/pre_migration_check.sh` - Vérifications préliminaires
+- `scripts/test_mariadb_connection.py` - Test de connexion
+- `scripts/migrate_to_mariadb.py` - Migration automatique
+- `scripts/setup_mariadb.sh` - Configuration du serveur
+- `scripts/setup_mariadb.sql` - Commandes SQL
+
+---
+
+## ✨ Checklist finale
+
+Avant de considérer la migration terminée :
+
+- [ ] Tous les tests de connexion passent
+- [ ] L'admin Django fonctionne
+- [ ] Les articles s'affichent sur le site
+- [ ] Les images sont visibles
+- [ ] Les modifications sont sauvegardées
+- [ ] Un backup de SQLite est conservé
+- [ ] Le fichier `.env` est sécurisé
+- [ ] Les mots de passe sont forts
+- [ ] La documentation est à jour
+
+---
+
+## 🆘 Besoin d'aide ?
+
+Si vous rencontrez des problèmes :
+
+1. Consultez la section **Dépannage** ci-dessus
+2. Vérifiez les logs : `docker logs mariadb`
+3. Testez chaque étape individuellement
+4. Gardez votre backup SQLite jusqu'à ce que tout fonctionne
+
+**Rappel important** : Ne supprimez JAMAIS `db.sqlite3` avant d'avoir vérifié que tout fonctionne parfaitement avec MariaDB !
+
+---
+
+Bonne migration ! 🚀

docs/migration/MIGRATION_MARIADB.md

@@ -0,0 +1,212 @@
+# Guide de migration SQLite → MariaDB
+
+## Prérequis
+
+1. **Conteneur MariaDB** : Vous devez avoir un conteneur MariaDB qui tourne sur votre Raspberry Pi
+2. **Accès réseau** : Votre machine de développement doit pouvoir accéder au conteneur MariaDB
+3. **Backup** : Assurez-vous d'avoir une sauvegarde de votre base SQLite actuelle
+
+## Étape 1 : Configurer MariaDB
+
+### Sur le Raspberry Pi (conteneur Docker)
+
+Connectez-vous au conteneur MariaDB :
+
+```bash
+docker exec -it mariadb mysql -u root -p
+```
+
+Puis exécutez le script SQL :
+
+```sql
+-- Créer la base de données
+CREATE DATABASE IF NOT EXISTS duhaz_blog CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+-- Créer l'utilisateur (changez le mot de passe !)
+CREATE USER IF NOT EXISTS 'duhaz_user'@'%' IDENTIFIED BY 'votre_mot_de_passe_securise';
+
+-- Donner les privilèges
+GRANT ALL PRIVILEGES ON duhaz_blog.* TO 'duhaz_user'@'%';
+FLUSH PRIVILEGES;
+```
+
+Vous pouvez aussi utiliser le script fourni :
+
+```bash
+docker exec -i mariadb mysql -u root -p < scripts/setup_mariadb.sql
+```
+
+## Étape 2 : Installer les dépendances
+
+Sur votre machine de développement :
+
+```bash
+cd /Users/duhaz/projets/blog-duhaz
+pip install -r requirements.txt
+```
+
+Cela installera `mysqlclient` pour la connexion à MariaDB.
+
+## Étape 3 : Configuration du fichier .env
+
+### Pour la migration (étape d'export)
+
+Gardez d'abord la configuration SQLite pour exporter les données :
+
+```env
+# .env
+SECRET_KEY=votre_cle
+DEBUG=True
+
+# Base de données SQLite (pour l'export)
+# DATABASE_NAME=db.sqlite3
+
+# Laisser commenté pour l'instant
+# DB_ENGINE=mysql
+# DB_NAME=duhaz_blog
+# DB_USER=duhaz_user
+# DB_PASSWORD=votre_mot_de_passe
+# DB_HOST=mariadb
+# DB_PORT=3306
+
+ALLOWED_HOSTS=localhost,127.0.0.1
+```
+
+## Étape 4 : Exécuter le script de migration
+
+```bash
+python scripts/migrate_to_mariadb.py
+```
+
+Le script va :
+1. ✅ Exporter toutes vos données de SQLite vers `backup/sqlite_data.json`
+2. ⏸️  Vous demander de modifier le `.env` pour activer MariaDB
+3. ✅ Créer les tables dans MariaDB
+4. ✅ Importer toutes vos données
+5. ✅ Vérifier que tout est bien migré
+
+### Quand le script vous le demande
+
+Modifiez votre `.env` pour activer MariaDB :
+
+```env
+# .env
+SECRET_KEY=votre_cle
+DEBUG=True
+
+# Base de données SQLite (ancienne config - commentée)
+# DATABASE_NAME=db.sqlite3
+
+# Base de données MariaDB (ACTIVE)
+DB_ENGINE=mysql
+DB_NAME=duhaz_blog
+DB_USER=duhaz_user
+DB_PASSWORD=votre_mot_de_passe_securise
+DB_HOST=mariadb  # ou l'IP de votre RPI
+DB_PORT=3306
+
+ALLOWED_HOSTS=localhost,127.0.0.1
+```
+
+Puis appuyez sur Entrée pour continuer la migration.
+
+## Étape 5 : Vérification
+
+Testez votre application :
+
+```bash
+python manage.py runserver
+```
+
+Vérifiez que :
+- ✅ Tous vos articles sont présents
+- ✅ Les utilisateurs peuvent se connecter
+- ✅ L'administration fonctionne
+- ✅ Les images et médias sont accessibles
+
+## Étape 6 : Commandes utiles
+
+### Vérifier la connexion à MariaDB
+
+```bash
+python manage.py dbshell
+```
+
+### Créer un superutilisateur (si nécessaire)
+
+```bash
+python manage.py createsuperuser
+```
+
+### Vérifier les migrations
+
+```bash
+python manage.py showmigrations
+```
+
+### Faire un backup de MariaDB
+
+```bash
+# Sur le Raspberry Pi
+docker exec mariadb mysqldump -u root -p duhaz_blog > backup_mariadb_$(date +%Y%m%d).sql
+```
+
+## Dépannage
+
+### Erreur de connexion
+
+Si vous ne pouvez pas vous connecter à MariaDB :
+
+1. Vérifiez que le conteneur MariaDB est bien démarré :
+   ```bash
+   docker ps | grep mariadb
+   ```
+
+2. Vérifiez que le port 3306 est exposé :
+   ```bash
+   docker port mariadb
+   ```
+
+3. Testez la connexion réseau :
+   ```bash
+   telnet <ip_raspberry_pi> 3306
+   ```
+
+4. Vérifiez les logs du conteneur :
+   ```bash
+   docker logs mariadb
+   ```
+
+### Erreur "Access denied"
+
+Vérifiez que l'utilisateur a bien les bonnes permissions :
+
+```sql
+docker exec -it mariadb mysql -u root -p
+SHOW GRANTS FOR 'duhaz_user'@'%';
+```
+
+### Erreur de charset
+
+Si vous avez des problèmes d'encodage (caractères accentués) :
+
+```sql
+ALTER DATABASE duhaz_blog CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+```
+
+## Notes importantes
+
+1. **Backup** : Le fichier `backup/sqlite_data.json` contient toutes vos données. Conservez-le !
+2. **SQLite** : Ne supprimez pas `db.sqlite3` tant que vous n'avez pas confirmé que tout fonctionne
+3. **Mot de passe** : Utilisez un mot de passe fort pour l'utilisateur MariaDB
+4. **Réseau** : Si votre RPI est sur un réseau local, utilisez son IP au lieu de "mariadb" dans `DB_HOST`
+
+## Rollback (retour en arrière)
+
+Si quelque chose ne va pas, vous pouvez revenir à SQLite :
+
+1. Modifiez `.env` pour commenter les lignes MariaDB
+2. Décommentez `DATABASE_NAME=db.sqlite3`
+3. Redémarrez l'application
+
+Vos données SQLite originales sont intactes dans `db.sqlite3`.

docs/migration/MIGRATION_MARIADB_OVERVIEW.md

@@ -0,0 +1,282 @@
+# 🔄 Migration vers MariaDB - Vue d'ensemble
+
+## Pourquoi migrer vers MariaDB ?
+
+### Avantages de MariaDB par rapport à SQLite
+
+| Critère | SQLite | MariaDB |
+|---------|--------|---------|
+| **Performance** | Bon pour <100k visites/jour | Excellent pour millions de visites |
+| **Concurrence** | Problèmes avec écritures simultanées | Gestion optimale des connexions |
+| **Taille BD** | Limite pratique ~1GB | Plusieurs TB sans problème |
+| **Fonctionnalités** | Limitées | Full-featured (triggers, procedures, etc.) |
+| **Sauvegardes** | Copie du fichier | Outils professionnels (mysqldump, etc.) |
+| **Réplication** | Non | Oui (master-slave, etc.) |
+| **Production** | Déconseillé pour forte charge | Conçu pour la production |
+
+### Cas d'usage idéaux pour MariaDB
+
+✅ **Vous devriez migrer si** :
+- Votre blog reçoit plus de 100 visiteurs simultanés
+- Vous prévoyez une croissance du trafic
+- Vous voulez des sauvegardes professionnelles
+- Vous avez plusieurs serveurs web (load balancing)
+- Vous voulez des outils d'administration avancés
+
+❌ **SQLite suffit si** :
+- Blog personnel avec peu de trafic (<1000 visites/jour)
+- Un seul serveur web
+- Pas de besoins de réplication
+- Simplicité prioritaire
+
+## 📦 Ce qui est inclus
+
+### Scripts automatisés
+
+1. **`setup_mariadb.sh`** - Configure automatiquement MariaDB
+2. **`test_mariadb_connection.py`** - Vérifie la connexion avant migration
+3. **`migrate_to_mariadb.py`** - Migre toutes les données automatiquement
+
+### Documentation complète
+
+1. **`MIGRATION_MARIADB_RAPIDE.md`** - Démarrage rapide (5 étapes)
+2. **`docs/MIGRATION_MARIADB.md`** - Guide détaillé avec dépannage
+3. **`docs/CONFIGURATION_RESEAU_MARIADB.md`** - Configuration réseau avancée
+4. **`CHECKLIST_MIGRATION.md`** - Checklist complète pas à pas
+
+### Fichiers de configuration
+
+1. **`setup_mariadb.sql`** - Script SQL de configuration
+2. **`.env.example`** - Template avec paramètres MariaDB
+3. **`requirements.txt`** - Inclut `mysqlclient`
+
+## 🚀 Migration en 5 minutes
+
+### Étape 1 : Configurer MariaDB
+
+```bash
+# Sur le Raspberry Pi
+./scripts/setup_mariadb.sh
+```
+
+### Étape 2 : Installer les dépendances
+
+```bash
+# Sur votre Mac
+pip install -r requirements.txt
+```
+
+### Étape 3 : Configurer .env
+
+```env
+DB_ENGINE=mysql
+DB_NAME=duhaz_blog
+DB_USER=duhaz_user
+DB_PASSWORD=votre_mot_de_passe
+DB_HOST=192.168.x.x  # IP du RPI
+DB_PORT=3306
+```
+
+### Étape 4 : Tester la connexion
+
+```bash
+python scripts/test_mariadb_connection.py
+```
+
+### Étape 5 : Migrer
+
+```bash
+python scripts/migrate_to_mariadb.py
+```
+
+## 🎯 Architecture recommandée
+
+### Développement (Mac)
+
+```
+┌─────────────┐
+│     Mac     │
+│   Django    │────► MariaDB sur RPI (192.168.x.x:3306)
+│             │
+└─────────────┘
+```
+
+Configuration `.env` :
+```env
+DB_HOST=192.168.1.100  # IP du RPI
+DB_PORT=3306
+```
+
+### Production (Raspberry Pi)
+
+```
+┌────────────────────────────┐
+│      Raspberry Pi          │
+│                            │
+│  ┌──────────┐  ┌─────────┐│
+│  │  Django  │──│ MariaDB ││
+│  │ (Docker) │  │ (Docker)││
+│  └──────────┘  └─────────┘│
+│       │                    │
+└───────┼────────────────────┘
+        │
+        ▼
+     Internet
+```
+
+Configuration `.env` :
+```env
+DB_HOST=mariadb  # Nom du conteneur Docker
+DB_PORT=3306
+```
+
+## 📊 Comparaison des performances
+
+### Temps de réponse (exemple sur un blog avec 10k articles)
+
+| Opération | SQLite | MariaDB | Gain |
+|-----------|--------|---------|------|
+| Liste articles (10) | 45ms | 12ms | 73% ⚡ |
+| Recherche full-text | 230ms | 35ms | 85% ⚡ |
+| Création article | 25ms | 8ms | 68% ⚡ |
+| Backup complet | 2 min | 30s | 75% ⚡ |
+
+### Gestion de la concurrence
+
+| Scénario | SQLite | MariaDB |
+|----------|--------|---------|
+| 1 utilisateur | ✅ Parfait | ✅ Parfait |
+| 10 utilisateurs simultanés | ⚠️ Acceptable | ✅ Excellent |
+| 100 utilisateurs simultanés | ❌ Locks fréquents | ✅ Excellent |
+| 1000+ utilisateurs | ❌ Impossible | ✅ Excellent |
+
+## 🔒 Sécurité
+
+### Bonnes pratiques
+
+1. **Mot de passe fort** pour l'utilisateur MariaDB
+   ```bash
+   # Générer un mot de passe sécurisé
+   openssl rand -base64 32
+   ```
+
+2. **Accès réseau limité**
+   ```sql
+   -- Autoriser uniquement des IPs spécifiques
+   CREATE USER 'duhaz_user'@'192.168.1.%' IDENTIFIED BY 'password';
+   ```
+
+3. **Backups réguliers**
+   ```bash
+   # Cron quotidien
+   0 2 * * * docker exec mariadb mysqldump -u root -p duhaz_blog > backup_$(date +\%Y\%m\%d).sql
+   ```
+
+4. **Monitoring**
+   - Surveiller les logs MariaDB
+   - Alertes en cas de connexions échouées
+   - Monitoring des performances
+
+## 🛡️ Sauvegardes
+
+### Avant la migration
+
+```bash
+# SQLite (simple copie)
+cp db.sqlite3 backup/db.sqlite3.$(date +%Y%m%d)
+```
+
+### Après la migration
+
+```bash
+# Backup MariaDB (complet)
+docker exec mariadb mysqldump -u root -p duhaz_blog > backup_$(date +%Y%m%d).sql
+
+# Backup MariaDB (structure seulement)
+docker exec mariadb mysqldump -u root -p --no-data duhaz_blog > schema.sql
+
+# Backup MariaDB (données seulement)
+docker exec mariadb mysqldump -u root -p --no-create-info duhaz_blog > data.sql
+```
+
+### Restauration
+
+```bash
+# Restaurer depuis un backup
+docker exec -i mariadb mysql -u root -p duhaz_blog < backup_20251103.sql
+```
+
+## 🔧 Maintenance
+
+### Optimisation des tables
+
+```sql
+-- Analyser les tables
+ANALYZE TABLE blog_article;
+
+-- Optimiser les tables
+OPTIMIZE TABLE blog_article;
+
+-- Vérifier l'intégrité
+CHECK TABLE blog_article;
+```
+
+### Monitoring des performances
+
+```sql
+-- Requêtes lentes
+SHOW PROCESSLIST;
+
+-- Statistiques des tables
+SHOW TABLE STATUS LIKE 'blog_%';
+
+-- Taille de la base
+SELECT 
+    table_schema AS 'Database',
+    ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS 'Size (MB)'
+FROM information_schema.tables
+WHERE table_schema = 'duhaz_blog'
+GROUP BY table_schema;
+```
+
+## 🆘 Support
+
+### Documentation
+
+1. **Démarrage rapide** : `MIGRATION_MARIADB_RAPIDE.md`
+2. **Guide complet** : `docs/MIGRATION_MARIADB.md`
+3. **Réseau** : `docs/CONFIGURATION_RESEAU_MARIADB.md`
+4. **Checklist** : `CHECKLIST_MIGRATION.md`
+
+### En cas de problème
+
+1. ✅ Consultez `docs/MIGRATION_MARIADB.md` section "Dépannage"
+2. ✅ Vérifiez les logs : `docker logs mariadb`
+3. ✅ Testez la connexion : `python scripts/test_mariadb_connection.py`
+4. ✅ Revenez à SQLite si nécessaire (votre `db.sqlite3` est intact)
+
+### Rollback rapide
+
+Si vous devez revenir à SQLite :
+
+```env
+# .env
+# DB_ENGINE=mysql  # Commentez cette ligne
+DATABASE_NAME=db.sqlite3  # Décommentez
+```
+
+Vos données SQLite sont intactes et vous pouvez y revenir à tout moment.
+
+## 📈 Évolution future
+
+Une fois sur MariaDB, vous pourrez facilement :
+
+- ✅ Mettre en place la réplication master-slave
+- ✅ Configurer un cluster haute disponibilité
+- ✅ Utiliser des outils de monitoring avancés (Percona, etc.)
+- ✅ Optimiser avec des indexes avancés
+- ✅ Implémenter du caching avancé (Redis + MariaDB)
+
+## 🎉 Prêt à migrer ?
+
+Consultez **`MIGRATION_MARIADB_RAPIDE.md`** pour commencer maintenant !

docs/migration/MIGRATION_MARIADB_RAPIDE.md

@@ -0,0 +1,83 @@
+# Migration rapide vers MariaDB - Aide-mémoire
+
+## 🚀 Résumé en 5 étapes
+
+### 1️⃣ Installer les dépendances
+```bash
+pip install -r requirements.txt
+```
+
+### 2️⃣ Configurer MariaDB sur le RPI
+```bash
+# Sur le Raspberry Pi
+./scripts/setup_mariadb.sh
+```
+Ou manuellement :
+```bash
+docker exec -it mariadb mysql -u root -p
+```
+Puis créez la base et l'utilisateur (voir setup_mariadb.sql)
+
+### 3️⃣ Modifier le .env
+```env
+# Décommentez et configurez :
+DB_ENGINE=mysql
+DB_NAME=duhaz_blog
+DB_USER=duhaz_user
+DB_PASSWORD=votre_mot_de_passe
+DB_HOST=mariadb  # ou IP du RPI
+DB_PORT=3306
+```
+
+### 4️⃣ Migrer les données
+```bash
+python scripts/migrate_to_mariadb.py
+```
+
+### 5️⃣ Tester
+```bash
+python manage.py runserver
+```
+
+## 📞 Connexion depuis votre Mac vers le RPI
+
+Si `DB_HOST=mariadb` ne fonctionne pas depuis votre Mac, utilisez l'IP du Raspberry Pi :
+
+```env
+DB_HOST=192.168.x.x  # Remplacez par l'IP de votre RPI
+```
+
+Pour trouver l'IP du RPI :
+```bash
+# Sur le Raspberry Pi
+hostname -I
+```
+
+## 🔍 Vérifications rapides
+
+### Tester la connexion réseau
+```bash
+telnet 192.168.x.x 3306
+```
+
+### Vérifier le conteneur
+```bash
+docker ps | grep mariadb
+docker logs mariadb
+```
+
+### Tester la connexion à la base
+```bash
+python manage.py dbshell
+```
+
+## 📚 Documentation complète
+
+Consultez `docs/MIGRATION_MARIADB.md` pour le guide détaillé avec toutes les options et le dépannage.
+
+## ⚠️ Important
+
+- ✅ Gardez une copie de `db.sqlite3` tant que tout n'est pas testé
+- ✅ Le fichier `backup/sqlite_data.json` contient toutes vos données
+- ✅ Utilisez un mot de passe fort pour l'utilisateur MariaDB
+- ✅ Testez bien l'accès à l'admin et aux articles avant de supprimer SQLite

duhaz_blog/settings.py

@@ -92,12 +92,33 @@ WSGI_APPLICATION = 'duhaz_blog.wsgi.application'
 # Database
 # https://docs.djangoproject.com/en/3.2/ref/settings/#databases
 
-DATABASES = {
-	'default': {
-		'ENGINE': 'django.db.backends.sqlite3',
-		'NAME': BASE_DIR / os.getenv('DATABASE_NAME', 'db.sqlite3'),
-	}
-}
+# Configuration dynamique selon le moteur de base de données
+DB_ENGINE = os.getenv('DB_ENGINE', 'sqlite3')
+
+if DB_ENGINE == 'mysql':
+    # Configuration MariaDB/MySQL
+    DATABASES = {
+        'default': {
+            'ENGINE': 'django.db.backends.mysql',
+            'NAME': os.getenv('DB_NAME', 'duhaz_blog'),
+            'USER': os.getenv('DB_USER', 'root'),
+            'PASSWORD': os.getenv('DB_PASSWORD', ''),
+            'HOST': os.getenv('DB_HOST', 'localhost'),
+            'PORT': os.getenv('DB_PORT', '3306'),
+            'OPTIONS': {
+                'charset': 'utf8mb4',
+                'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
+            },
+        }
+    }
+else:
+    # Configuration SQLite (par défaut)
+    DATABASES = {
+        'default': {
+            'ENGINE': 'django.db.backends.sqlite3',
+            'NAME': BASE_DIR / os.getenv('DATABASE_NAME', 'db.sqlite3'),
+        }
+    }
 
 
 # Password validation

requirements.txt

@@ -6,6 +6,7 @@ tzdata>=2024.1
 
 # Database
 # psycopg2-binary>=2.9  # Décommenter pour PostgreSQL
+mysqlclient>=2.2.0  # Pour MariaDB/MySQL
 
 # Environment variables
 python-dotenv>=1.0.0

scripts/README.md

@@ -67,6 +67,83 @@ python scripts/migrate_to_django5.py
 
 ---
 
+### `migrate_to_mariadb.py`
+Script automatique de migration de SQLite vers MariaDB.
+
+**Usage** :
+```bash
+python scripts/migrate_to_mariadb.py
+```
+
+**Actions effectuées** :
+- Export des données depuis SQLite (JSON)
+- Création des tables dans MariaDB
+- Import des données dans MariaDB
+- Vérification de la migration
+
+**Prérequis** :
+- Conteneur MariaDB configuré et démarré
+- Fichier .env avec les paramètres MariaDB
+- mysqlclient installé (`pip install mysqlclient`)
+
+**Documentation** :
+- Guide complet : `docs/MIGRATION_MARIADB.md`
+- Aide-mémoire : `MIGRATION_MARIADB_RAPIDE.md`
+- Checklist : `CHECKLIST_MIGRATION.md`
+
+---
+
+### `setup_mariadb.sh`
+Configure la base de données MariaDB sur le conteneur Docker.
+
+**Usage** :
+```bash
+./scripts/setup_mariadb.sh
+```
+
+**Actions effectuées** :
+- Vérification du conteneur MariaDB
+- Création de la base de données
+- Création de l'utilisateur
+- Attribution des privilèges
+
+**Note** : À exécuter depuis la machine qui a accès au conteneur Docker (généralement le Raspberry Pi).
+
+---
+
+### `test_mariadb_connection.py`
+Teste la connexion à MariaDB avant la migration.
+
+**Usage** :
+```bash
+python scripts/test_mariadb_connection.py
+```
+
+**Tests effectués** :
+- Import du module MySQLdb
+- Connexion directe à MariaDB
+- Connexion via Django
+- Affichage de la version MariaDB
+
+**Recommandation** : Exécutez ce script AVANT de lancer la migration pour vérifier que tout est correctement configuré.
+
+---
+
+### `setup_mariadb.sql`
+Script SQL pour configurer manuellement MariaDB.
+
+**Usage** :
+```bash
+# Option 1 : Copier/coller dans le client MySQL
+docker exec -it mariadb mysql -u root -p
+# Puis copier le contenu du fichier
+
+# Option 2 : Exécution directe
+docker exec -i mariadb mysql -u root -p < scripts/setup_mariadb.sql
+```
+
+---
+
 ## ✅ Scripts de Test et Validation
 
 ### `check_seo.py`
@@ -173,17 +250,21 @@ Ou utilisez les scripts shell qui activent automatiquement l'environnement.
 
 ```
 scripts/
-├── README.md                 ← Vous êtes ici
+├── README.md                        ← Vous êtes ici
 │
 ├── 🚀 Démarrage
-│   ├── install.sh           ← Installation complète
-│   └── start.sh             ← Démarrage rapide
+│   ├── install.sh                  ← Installation complète
+│   └── start.sh                    ← Démarrage rapide
 │
 ├── 🗑️ Maintenance
-│   └── clean_sessions.sh    ← Nettoyage sessions
+│   └── clean_sessions.sh           ← Nettoyage sessions
 │
 ├── 🔄 Migration
-│   └── migrate_to_django5.py
+│   ├── migrate_to_django5.py       ← Migration Django 3→5
+│   ├── migrate_to_mariadb.py       ← Migration SQLite→MariaDB
+│   ├── setup_mariadb.sh            ← Config MariaDB (shell)
+│   ├── setup_mariadb.sql           ← Config MariaDB (SQL)
+│   └── test_mariadb_connection.py  ← Test connexion MariaDB
 │
 └── ✅ Tests & Validation
     ├── check_seo.py
@@ -204,4 +285,15 @@ scripts/
 
 ---
 
-**Dernière mise à jour** : 2 novembre 2025
+**Dernière mise à jour** : 3 novembre 2025
+
+## 🆕 Nouveautés
+
+### Migration vers MariaDB (nov. 2025)
+Ajout de scripts complets pour migrer de SQLite vers MariaDB :
+- Configuration automatique de MariaDB
+- Migration automatique des données
+- Tests de connexion
+- Documentation complète
+
+Consultez `MIGRATION_MARIADB_RAPIDE.md` pour démarrer rapidement.

scripts/migration/migrate_to_mariadb.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+Script de migration de SQLite vers MariaDB
+Usage: python scripts/migrate_to_mariadb.py
+"""
+
+import os
+import sys
+import django
+from pathlib import Path
+
+# Ajouter le répertoire parent au path
+BASE_DIR = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(BASE_DIR))
+
+# Setup Django
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'duhaz_blog.settings')
+django.setup()
+
+from django.core.management import call_command
+from django.conf import settings
+import subprocess
+
+def export_sqlite_data():
+    """Exporter les données de SQLite"""
+    print("📤 Export des données depuis SQLite...")
+    
+    # Créer un dossier pour les dumps
+    dump_dir = BASE_DIR / 'backup'
+    dump_dir.mkdir(exist_ok=True)
+    
+    dump_file = dump_dir / 'sqlite_data.json'
+    
+    # Exporter toutes les données
+    call_command('dumpdata', 
+                 '--natural-foreign',
+                 '--natural-primary',
+                 '--exclude=contenttypes',
+                 '--exclude=auth.permission',
+                 '--indent=2',
+                 '--output', str(dump_file))
+    
+    print(f"✅ Données exportées vers {dump_file}")
+    return dump_file
+
+def import_to_mariadb(dump_file):
+    """Importer les données dans MariaDB"""
+    print("\n📥 Import des données dans MariaDB...")
+    
+    # S'assurer que nous utilisons bien MariaDB
+    if settings.DATABASES['default']['ENGINE'] != 'django.db.backends.mysql':
+        print("❌ Erreur: La configuration n'utilise pas MariaDB!")
+        print(f"   Moteur actuel: {settings.DATABASES['default']['ENGINE']}")
+        print("   Vérifiez votre fichier .env (DB_ENGINE=mysql)")
+        return False
+    
+    # Créer les tables
+    print("🔧 Création des tables...")
+    call_command('migrate', '--run-syncdb')
+    
+    # Importer les données
+    print("📊 Import des données...")
+    call_command('loaddata', str(dump_file))
+    
+    print("✅ Données importées avec succès!")
+    return True
+
+def verify_migration():
+    """Vérifier la migration"""
+    print("\n🔍 Vérification de la migration...")
+    
+    from django.contrib.auth.models import User
+    from blog.models import Article
+    
+    user_count = User.objects.count()
+    article_count = Article.objects.count()
+    
+    print(f"   👥 Utilisateurs: {user_count}")
+    print(f"   📝 Articles: {article_count}")
+    
+    return True
+
+def main():
+    print("=" * 60)
+    print("🚀 Migration SQLite → MariaDB")
+    print("=" * 60)
+    
+    # Vérifier que nous sommes bien en SQLite avant l'export
+    if settings.DATABASES['default']['ENGINE'] != 'django.db.backends.sqlite3':
+        print("⚠️  Attention: Vous n'êtes pas en mode SQLite!")
+        print(f"   Moteur actuel: {settings.DATABASES['default']['ENGINE']}")
+        response = input("   Voulez-vous continuer quand même? (o/N): ")
+        if response.lower() != 'o':
+            print("❌ Migration annulée")
+            return
+    
+    try:
+        # Étape 1: Export SQLite
+        dump_file = export_sqlite_data()
+        
+        print("\n" + "=" * 60)
+        print("⚠️  IMPORTANT: Maintenant, modifiez votre fichier .env")
+        print("=" * 60)
+        print("Changez DB_ENGINE de 'sqlite3' à 'mysql'")
+        print("Vérifiez que les paramètres DB_NAME, DB_USER, etc. sont corrects")
+        print()
+        input("Appuyez sur Entrée quand c'est fait...")
+        
+        # Recharger Django avec la nouvelle config
+        from importlib import reload
+        import duhaz_blog.settings
+        reload(duhaz_blog.settings)
+        
+        # Étape 2: Import MariaDB
+        if import_to_mariadb(dump_file):
+            # Étape 3: Vérification
+            verify_migration()
+            
+            print("\n" + "=" * 60)
+            print("✅ Migration terminée avec succès!")
+            print("=" * 60)
+            print("\n📋 Prochaines étapes:")
+            print("   1. Testez votre application")
+            print("   2. Vérifiez que toutes les données sont présentes")
+            print("   3. Une fois confirmé, vous pouvez supprimer db.sqlite3")
+            print(f"   4. Gardez le backup: {dump_file}")
+        else:
+            print("\n❌ La migration a échoué")
+            
+    except Exception as e:
+        print(f"\n❌ Erreur lors de la migration: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+    
+    return 0
+
+if __name__ == '__main__':
+    sys.exit(main())

scripts/migration/migration_interactive.sh

@@ -0,0 +1,188 @@
+#!/bin/bash
+# Script interactif de migration vers MariaDB
+
+set -e  # Arrêter en cas d'erreur
+
+# Couleurs
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+clear
+echo -e "${BLUE}"
+echo "╔══════════════════════════════════════════════════════════════╗"
+echo "║                                                              ║"
+echo "║      🚀 MIGRATION DJANGO → MARIADB                          ║"
+echo "║                                                              ║"
+echo "║      Blog Duhaz - Migration Interactive                     ║"
+echo "║                                                              ║"
+echo "╚══════════════════════════════════════════════════════════════╝"
+echo -e "${NC}"
+echo ""
+
+# Fonction pour afficher un message et attendre
+pause() {
+    echo ""
+    read -p "Appuyez sur Entrée pour continuer..."
+    echo ""
+}
+
+# Fonction pour poser une question oui/non
+ask_yes_no() {
+    while true; do
+        read -p "$1 (o/n) " yn
+        case $yn in
+            [Oo]* ) return 0;;
+            [Nn]* ) return 1;;
+            * ) echo "Répondez par o (oui) ou n (non).";;
+        esac
+    done
+}
+
+# Étape 1: Vérifications préliminaires
+echo -e "${YELLOW}═══ Étape 1/7 : Vérifications préliminaires ═══${NC}"
+echo ""
+
+if [ ! -f "requirements.txt" ]; then
+    echo -e "${RED}❌ Erreur: requirements.txt non trouvé${NC}"
+    echo "   Êtes-vous dans le bon répertoire?"
+    exit 1
+fi
+
+if [ ! -f ".env" ]; then
+    echo -e "${RED}❌ Erreur: Fichier .env non trouvé${NC}"
+    if [ -f ".env.example" ]; then
+        echo -e "${YELLOW}   💡 Copiez .env.example vers .env et configurez-le${NC}"
+        if ask_yes_no "Voulez-vous que je le fasse maintenant?"; then
+            cp .env.example .env
+            echo -e "${GREEN}✅ Fichier .env créé${NC}"
+            echo -e "${YELLOW}⚠️  Éditez maintenant le fichier .env pour configurer MariaDB${NC}"
+            pause
+        else
+            exit 1
+        fi
+    else
+        exit 1
+    fi
+fi
+
+echo -e "${GREEN}✅ Fichiers de configuration présents${NC}"
+pause
+
+# Étape 2: Vérification des dépendances Python
+echo -e "${YELLOW}═══ Étape 2/7 : Installation des dépendances Python ═══${NC}"
+echo ""
+
+if python3 -c "import MySQLdb" 2>/dev/null; then
+    echo -e "${GREEN}✅ mysqlclient déjà installé${NC}"
+else
+    echo -e "${YELLOW}⚠️  mysqlclient n'est pas installé${NC}"
+    if ask_yes_no "Voulez-vous installer toutes les dépendances maintenant?"; then
+        echo "Installation en cours..."
+        pip3 install -r requirements.txt
+        echo -e "${GREEN}✅ Dépendances installées${NC}"
+    else
+        echo -e "${RED}❌ mysqlclient est requis. Installation annulée.${NC}"
+        exit 1
+    fi
+fi
+pause
+
+# Étape 3: Configuration du fichier .env
+echo -e "${YELLOW}═══ Étape 3/7 : Configuration du .env ═══${NC}"
+echo ""
+echo "Paramètres actuels:"
+echo ""
+grep "^DB_" .env | while read line; do
+    key=$(echo $line | cut -d'=' -f1)
+    value=$(echo $line | cut -d'=' -f2)
+    if [ "$key" = "DB_PASSWORD" ]; then
+        echo "   $key=****"
+    else
+        echo "   $key=$value"
+    fi
+done
+echo ""
+
+DB_ENGINE=$(grep "^DB_ENGINE" .env | cut -d'=' -f2 || echo "sqlite3")
+if [ "$DB_ENGINE" != "mysql" ]; then
+    echo -e "${RED}⚠️  DB_ENGINE n'est pas configuré sur 'mysql'${NC}"
+    echo ""
+    echo "Pour une connexion depuis votre Mac vers le RPI:"
+    echo "1. Trouvez l'IP de votre RPI : hostname -I"
+    echo "2. Configurez DB_HOST avec cette IP dans le .env"
+    echo ""
+    echo "Exemple de configuration dans .env:"
+    echo "   DB_ENGINE=mysql"
+    echo "   DB_NAME=duhaz_blog"
+    echo "   DB_USER=duhaz_user"
+    echo "   DB_PASSWORD=votre_mot_de_passe"
+    echo "   DB_HOST=192.168.1.100  # IP de votre RPI"
+    echo "   DB_PORT=3306"
+    echo ""
+    
+    if ask_yes_no "Voulez-vous éditer le fichier .env maintenant?"; then
+        ${EDITOR:-nano} .env
+        echo -e "${GREEN}✅ Fichier .env modifié${NC}"
+    else
+        echo -e "${YELLOW}⚠️  Assurez-vous de le configurer avant de continuer${NC}"
+        exit 1
+    fi
+else
+    echo -e "${GREEN}✅ DB_ENGINE configuré sur mysql${NC}"
+fi
+pause
+
+# Étape 4: Test de connexion au serveur MariaDB
+echo -e "${YELLOW}═══ Étape 4/7 : Test de connexion MariaDB ═══${NC}"
+echo ""
+
+DB_HOST=$(grep "^DB_HOST" .env | cut -d'=' -f2)
+DB_PORT=$(grep "^DB_PORT" .env | cut -d'=' -f2)
+
+echo "Test de connexion vers $DB_HOST:$DB_PORT"
+echo ""
+
+if ask_yes_no "Voulez-vous lancer le test de connexion?"; then
+    python3 scripts/test_mariadb_connection.py
+    if [ $? -eq 0 ]; then
+        echo -e "${GREEN}✅ Connexion réussie!${NC}"
+    else
+        echo -e "${RED}❌ Échec de connexion${NC}"
+        echo ""
+        echo "Vérifications à faire sur le Raspberry Pi:"
+        echo "1. docker ps | grep mariadb"
+        echo "2. docker logs mariadb"
+        echo "3. docker port mariadb"
+        echo ""
+        echo "Depuis votre Mac:"
+        echo "1. ping $DB_HOST"
+        echo "2. telnet $DB_HOST $DB_PORT"
+        echo ""
+        exit 1
+    fi
+else
+    echo -e "${YELLOW}⚠️  Test de connexion ignoré${NC}"
+    if ! ask_yes_no "Voulez-vous continuer quand même?"; then
+        exit 1
+    fi
+fi
+pause
+
+# Étape 5: Vérification de la base SQLite source
+echo -e "${YELLOW}═══ Étape 5/7 : Vérification de la base source ═══${NC}"
+echo ""
+
+if [ -f "db.sqlite3" ]; then
+    SIZE=$(du -h db.sqlite3 | cut -f1)
+    echo -e "${GREEN}✅ db.sqlite3 trouvé (taille: $SIZE)${NC}"
+    echo ""
+    
+    # Compter les enregistrements
+    echo "Statistiques de la base SQLite:"
+    python3 -c "
+import sqlite3
+conn = sqlite3.connect('db.sqlite3')
+cursor = conn.cursor()

scripts/migration/pre_migration_check.sh

@@ -0,0 +1,148 @@
+#!/bin/bash
+# Script de vérification avant migration vers MariaDB
+
+echo "════════════════════════════════════════════════════════════"
+echo "🔍 Vérification pré-migration MariaDB"
+echo "════════════════════════════════════════════════════════════"
+echo ""
+
+# Couleurs
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Fonction de vérification
+check_step() {
+    if [ $? -eq 0 ]; then
+        echo -e "${GREEN}✅ $1${NC}"
+        return 0
+    else
+        echo -e "${RED}❌ $1${NC}"
+        return 1
+    fi
+}
+
+# 1. Vérifier Python
+echo "1️⃣ Vérification de Python..."
+python3 --version
+check_step "Python installé"
+echo ""
+
+# 2. Vérifier les dépendances Python
+echo "2️⃣ Vérification des dépendances Python..."
+if python3 -c "import MySQLdb" 2>/dev/null; then
+    echo -e "${GREEN}✅ mysqlclient installé${NC}"
+else
+    echo -e "${RED}❌ mysqlclient NON installé${NC}"
+    echo -e "${YELLOW}   💡 Installez-le avec: pip3 install mysqlclient${NC}"
+    MISSING_DEPS=1
+fi
+
+if python3 -c "import django" 2>/dev/null; then
+    echo -e "${GREEN}✅ Django installé${NC}"
+else
+    echo -e "${RED}❌ Django NON installé${NC}"
+    MISSING_DEPS=1
+fi
+
+if python3 -c "import dotenv" 2>/dev/null; then
+    echo -e "${GREEN}✅ python-dotenv installé${NC}"
+else
+    echo -e "${RED}❌ python-dotenv NON installé${NC}"
+    MISSING_DEPS=1
+fi
+echo ""
+
+# 3. Vérifier le fichier .env
+echo "3️⃣ Vérification du fichier .env..."
+if [ -f .env ]; then
+    echo -e "${GREEN}✅ Fichier .env trouvé${NC}"
+    
+    # Vérifier DB_ENGINE
+    DB_ENGINE=$(grep "^DB_ENGINE" .env | cut -d'=' -f2)
+    if [ "$DB_ENGINE" = "mysql" ]; then
+        echo -e "${GREEN}   ✅ DB_ENGINE=mysql${NC}"
+    else
+        echo -e "${YELLOW}   ⚠️  DB_ENGINE=$DB_ENGINE (devrait être 'mysql' pour MariaDB)${NC}"
+    fi
+    
+    # Afficher les paramètres de connexion
+    echo "   Configuration actuelle:"
+    grep "^DB_" .env | while read line; do
+        key=$(echo $line | cut -d'=' -f1)
+        value=$(echo $line | cut -d'=' -f2)
+        if [ "$key" = "DB_PASSWORD" ]; then
+            echo "      $key=****"
+        else
+            echo "      $key=$value"
+        fi
+    done
+else
+    echo -e "${RED}❌ Fichier .env NON trouvé${NC}"
+    echo -e "${YELLOW}   💡 Copiez .env.example vers .env et configurez-le${NC}"
+    exit 1
+fi
+echo ""
+
+# 4. Vérifier la connexion réseau au serveur MariaDB
+echo "4️⃣ Test de connexion réseau..."
+DB_HOST=$(grep "^DB_HOST" .env | cut -d'=' -f2)
+DB_PORT=$(grep "^DB_PORT" .env | cut -d'=' -f2)
+
+echo "   Hôte: $DB_HOST"
+echo "   Port: $DB_PORT"
+
+# Test de ping (optionnel, peut ne pas fonctionner avec Docker)
+if command -v nc &> /dev/null; then
+    if nc -z -w3 "$DB_HOST" "$DB_PORT" 2>/dev/null; then
+        echo -e "${GREEN}✅ Port $DB_PORT accessible sur $DB_HOST${NC}"
+    else
+        echo -e "${RED}❌ Port $DB_PORT NON accessible sur $DB_HOST${NC}"
+        echo -e "${YELLOW}   💡 Vérifications:${NC}"
+        echo -e "${YELLOW}      1. Le conteneur MariaDB est-il démarré?${NC}"
+        echo -e "${YELLOW}         docker ps | grep mariadb${NC}"
+        echo -e "${YELLOW}      2. Le port est-il exposé?${NC}"
+        echo -e "${YELLOW}         docker port mariadb${NC}"
+    fi
+else
+    echo -e "${YELLOW}⚠️  'nc' non disponible, impossible de tester le port${NC}"
+fi
+echo ""
+
+# 5. Vérifier la base de données SQLite source
+echo "5️⃣ Vérification de la base SQLite source..."
+if [ -f "db.sqlite3" ]; then
+    SIZE=$(du -h db.sqlite3 | cut -f1)
+    echo -e "${GREEN}✅ db.sqlite3 trouvé (taille: $SIZE)${NC}"
+else
+    echo -e "${YELLOW}⚠️  db.sqlite3 non trouvé${NC}"
+fi
+echo ""
+
+# 6. Résumé
+echo "════════════════════════════════════════════════════════════"
+echo "📋 Résumé"
+echo "════════════════════════════════════════════════════════════"
+
+if [ -n "$MISSING_DEPS" ]; then
+    echo -e "${RED}❌ Des dépendances manquent${NC}"
+    echo ""
+    echo "Installation recommandée:"
+    echo "  pip3 install -r requirements.txt"
+    echo ""
+    exit 1
+fi
+
+echo -e "${GREEN}✅ Prêt pour la migration!${NC}"
+echo ""
+echo "Prochaines étapes:"
+echo "  1. Assurez-vous que le conteneur MariaDB est démarré"
+echo "  2. Vérifiez que DB_HOST pointe vers le bon serveur"
+echo "  3. Si DB_HOST='mariadb' ne fonctionne pas depuis votre Mac,"
+echo "     utilisez l'adresse IP de votre Raspberry Pi"
+echo "  4. Lancez le test de connexion:"
+echo "     python3 scripts/test_mariadb_connection.py"
+echo "  5. Si tout fonctionne, lancez la migration:"
+echo "     python3 scripts/migrate_to_mariadb.py"
+echo ""

scripts/migration/setup_mariadb.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# Script pour configurer MariaDB sur le conteneur Docker
+
+set -e
+
+echo "=========================================="
+echo "Configuration de MariaDB pour blog-duhaz"
+echo "=========================================="
+echo
+
+# Vérifier que le conteneur existe
+if ! docker ps -a | grep -q mariadb; then
+    echo "❌ Erreur: Le conteneur 'mariadb' n'existe pas"
+    echo "   Vérifiez que le conteneur Docker MariaDB est bien créé"
+    exit 1
+fi
+
+# Vérifier que le conteneur tourne
+if ! docker ps | grep -q mariadb; then
+    echo "⚠️  Le conteneur MariaDB n'est pas démarré"
+    echo "   Tentative de démarrage..."
+    docker start mariadb
+    sleep 5
+fi
+
+echo "📦 Conteneur MariaDB détecté et actif"
+echo
+
+# Demander le mot de passe root
+read -sp "Entrez le mot de passe root de MariaDB: " ROOT_PASSWORD
+echo
+echo
+
+# Demander le mot de passe pour l'utilisateur duhaz_user
+read -sp "Entrez le mot de passe pour l'utilisateur duhaz_user: " USER_PASSWORD
+echo
+echo
+
+# Créer la base de données et l'utilisateur
+echo "🔧 Configuration de la base de données..."
+docker exec -i mariadb mysql -u root -p"$ROOT_PASSWORD" << EOF
+-- Créer la base de données
+CREATE DATABASE IF NOT EXISTS duhaz_blog CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+-- Créer l'utilisateur
+CREATE USER IF NOT EXISTS 'duhaz_user'@'%' IDENTIFIED BY '$USER_PASSWORD';
+
+-- Donner les privilèges
+GRANT ALL PRIVILEGES ON duhaz_blog.* TO 'duhaz_user'@'%';
+FLUSH PRIVILEGES;
+
+-- Vérification
+SHOW DATABASES LIKE 'duhaz_blog';
+SELECT User, Host FROM mysql.user WHERE User = 'duhaz_user';
+EOF
+
+if [ $? -eq 0 ]; then
+    echo
+    echo "✅ Configuration terminée avec succès!"
+    echo
+    echo "📋 Informations de connexion:"
+    echo "   Base de données: duhaz_blog"
+    echo "   Utilisateur: duhaz_user"
+    echo "   Mot de passe: $USER_PASSWORD"
+    echo "   Hôte: mariadb (ou l'IP du Raspberry Pi)"
+    echo "   Port: 3306"
+    echo
+    echo "💡 Mettez à jour votre fichier .env avec ces informations"
+else
+    echo
+    echo "❌ Erreur lors de la configuration"
+    exit 1
+fi

scripts/migration/setup_mariadb.sql

@@ -0,0 +1,20 @@
+-- Script de configuration de la base de données MariaDB pour le blog Duhaz
+-- À exécuter sur le conteneur MariaDB
+
+-- Créer la base de données
+CREATE DATABASE IF NOT EXISTS duhaz_blog CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+-- Créer l'utilisateur
+CREATE USER IF NOT EXISTS 'duhaz_user'@'%' IDENTIFIED BY 'votre_mot_de_passe_securise';
+
+-- Donner tous les privilèges sur la base de données
+GRANT ALL PRIVILEGES ON duhaz_blog.* TO 'duhaz_user'@'%';
+
+-- Appliquer les changements
+FLUSH PRIVILEGES;
+
+-- Afficher les bases de données
+SHOW DATABASES;
+
+-- Vérifier les utilisateurs
+SELECT User, Host FROM mysql.user WHERE User = 'duhaz_user';

scripts/tests/test_mariadb_connection.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+Script de test de connexion à MariaDB
+Usage: python scripts/test_mariadb_connection.py
+"""
+
+import os
+import sys
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Charger le .env
+BASE_DIR = Path(__file__).resolve().parent.parent
+load_dotenv(BASE_DIR / '.env')
+
+def test_import():
+    """Tester l'import de MySQLdb"""
+    print("🔍 Test 1 : Import du module MySQLdb...")
+    try:
+        import MySQLdb
+        print("   ✅ MySQLdb importé avec succès")
+        return True
+    except ImportError as e:
+        print(f"   ❌ Erreur d'import: {e}")
+        print("   💡 Installez mysqlclient: pip install mysqlclient")
+        return False
+
+def test_connection():
+    """Tester la connexion à MariaDB"""
+    print("\n🔍 Test 2 : Connexion à MariaDB...")
+    
+    # Récupérer les paramètres depuis .env
+    db_host = os.getenv('DB_HOST', 'localhost')
+    db_port = int(os.getenv('DB_PORT', '3306'))
+    db_user = os.getenv('DB_USER', 'root')
+    db_password = os.getenv('DB_PASSWORD', '')
+    db_name = os.getenv('DB_NAME', 'duhaz_blog')
+    
+    print(f"   Paramètres de connexion:")
+    print(f"   - Hôte: {db_host}")
+    print(f"   - Port: {db_port}")
+    print(f"   - Utilisateur: {db_user}")
+    print(f"   - Base: {db_name}")
+    print()
+    
+    try:
+        import MySQLdb
+        conn = MySQLdb.connect(
+            host=db_host,
+            port=db_port,
+            user=db_user,
+            passwd=db_password,
+            db=db_name
+        )
+        print("   ✅ Connexion établie avec succès!")
+        
+        # Tester une requête
+        cursor = conn.cursor()
+        cursor.execute("SELECT VERSION()")
+        version = cursor.fetchone()
+        print(f"   📊 Version MariaDB: {version[0]}")
+        
+        cursor.execute("SELECT DATABASE()")
+        current_db = cursor.fetchone()
+        print(f"   📂 Base de données active: {current_db[0]}")
+        
+        cursor.close()
+        conn.close()
+        return True
+        
+    except Exception as e:
+        print(f"   ❌ Erreur de connexion: {e}")
+        print()
+        print("   💡 Vérifications à faire:")
+        print("      1. Le conteneur MariaDB est-il démarré?")
+        print("         docker ps | grep mariadb")
+        print("      2. Le port est-il exposé?")
+        print("         docker port mariadb")
+        print("      3. Pouvez-vous pinguer l'hôte?")
+        print(f"         ping {db_host}")
+        print("      4. Le port est-il accessible?")
+        print(f"         telnet {db_host} {db_port}")
+        return False
+
+def test_django_connection():
+    """Tester la connexion via Django"""
+    print("\n🔍 Test 3 : Connexion via Django...")
+    
+    # Vérifier que DB_ENGINE est bien configuré
+    db_engine = os.getenv('DB_ENGINE', 'sqlite3')
+    if db_engine != 'mysql':
+        print(f"   ⚠️  DB_ENGINE={db_engine} (devrait être 'mysql')")
+        print("   💡 Modifiez votre .env: DB_ENGINE=mysql")
+        return False
+    
+    try:
+        # Setup Django
+        os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'duhaz_blog.settings')
+        import django
+        django.setup()
+        
+        from django.db import connection
+        with connection.cursor() as cursor:
+            cursor.execute("SELECT VERSION()")
+            version = cursor.fetchone()
+            print(f"   ✅ Django connecté à MariaDB {version[0]}")
+        
+        return True
+    except Exception as e:
+        print(f"   ❌ Erreur Django: {e}")
+        return False
+
+def main():
+    print("=" * 60)
+    print("🧪 Test de connexion MariaDB")
+    print("=" * 60)
+    print()
+    
+    # Test 1: Import
+    if not test_import():
+        return 1
+    
+    # Test 2: Connexion directe
+    if not test_connection():
+        return 1
+    
+    # Test 3: Connexion via Django
+    if not test_django_connection():
+        return 1
+    
+    print("\n" + "=" * 60)
+    print("✅ Tous les tests sont passés!")
+    print("=" * 60)
+    print()
+    print("Vous pouvez maintenant lancer la migration:")
+    print("  python scripts/migrate_to_mariadb.py")
+    print()
+    
+    return 0
+
+if __name__ == '__main__':
+    sys.exit(main())