Guide de migration de base de données¶

Navigation:

Guide de sélection de base de données - Quelle base de données choisir
Guide de migration de base de données ← Vous êtes ici
Retour au README

Ce guide vous aide à migrer entre différents systèmes de bases de données dans les projets go-starter-kit.

Prérequis¶

Important

La migration de base de données n'est pas automatisée. Vous devrez:

Exporter les données de la base source
Régénérer le projet avec la base cible
Importer les données vers la base cible
Tester minutieusement

Chemins de migration¶

PostgreSQL ↔ MySQL¶

Difficulté: Facile (tous deux SQL, compatibles GORM)

Étapes:

Exporter les données de la base source

# Export PostgreSQL
pg_dump -U postgres -h localhost -d monapp -F c -b -v -f backup.dump

# Export MySQL
mysqldump -u root -p monapp > backup.sql

Régénérer le projet avec la base cible

# Postgres → MySQL
create-go-starter monapp --database=mysql

# MySQL → Postgres
create-go-starter monapp --database=postgres

Convertir la syntaxe SQL si nécessaire
La plupart des différences sont gérées par GORM
Changements courants:
- Serial → AUTO_INCREMENT (géré par GORM)
- BOOLEAN → TINYINT(1) (géré par GORM)
- TEXT vs LONGTEXT (généralement compatible)

Pour MySQL → PostgreSQL:

# Convertir le dump MySQL en format PostgreSQL
# Option 1: Utiliser pgloader (recommandé)
pgloader mysql://user:pass@localhost/monapp postgresql://postgres:pass@localhost/monapp

# Option 2: Conversion manuelle
# Remplacer AUTO_INCREMENT par SERIAL
# Remplacer `backticks` par "quotes"
# Ajuster les types de données

Pour PostgreSQL → MySQL:

# Exporter en SQL puis convertir
pg_dump -U postgres monapp -f dump.sql
# Éditer dump.sql: remplacer SERIAL par AUTO_INCREMENT, etc.
mysql -u root -p monapp < dump_converted.sql

Importer les données

# Import PostgreSQL
pg_restore -U postgres -h localhost -d monapp backup.dump

# Import MySQL
mysql -u root -p monapp < backup.sql

Tester les migrations et requêtes

go run ./cmd/main.go
# Vérifier que tous les endpoints fonctionnent correctement

Problèmes courants: - Serial vs AUTO_INCREMENT (géré par GORM) - Certains types de données diffèrent (TEXT vs LONGTEXT) - La syntaxe des fonctions peut différer (DATE_ADD vs INTERVAL) - Identifiants: MySQL utilise backticks, PostgreSQL utilise "double quotes"

Outils recommandés: - pgloader: Migration automatique MySQL→PostgreSQL - mysql2postgres: Script de conversion de schemas - GORM AutoMigrate: Recréer le schéma automatiquement (perte de données custom)

SQL → SQLite (Dégradation)¶

Difficulté: Moyen (réduction de fonctionnalités)

Quand faire ceci: - Passage de production au développement local - Création d'une version démo portable - Simplification de l'infrastructure pour petits projets

Étapes:

Exporter les données en SQL ou CSV

# Export PostgreSQL en CSV
psql -U postgres -d monapp -c "COPY users TO '/tmp/users.csv' WITH CSV HEADER;"

# Export MySQL en CSV
mysql -u root -p monapp -e "SELECT * FROM users INTO OUTFILE '/tmp/users.csv'
  FIELDS TERMINATED BY ',' ENCLOSED BY '\"' LINES TERMINATED BY '\n';"

Régénérer le projet

create-go-starter monapp --database=sqlite

Importer un jeu de données limité

# SQLite ne gère pas bien les grands jeux de données
# Importer uniquement les données essentielles
sqlite3 monapp.db < import.sql

Retirer les fonctionnalités SQL avancées
Pas de procédures stockées
Support des transactions limité
Pas d'écritures concurrentes

Limitations:

Pas d'écritures concurrentes (verrouillage au niveau base)
Types de données limités
Pas de procédures stockées
Pas de gestion utilisateurs/permissions
Non adapté pour la production à grande échelle

Cas d'usage recommandés: - Environnements de développement local - Démos portables - Pipelines de tests et CI/CD - Applications à petite échelle (<100 utilisateurs)

SQLite → SQL (Mise à niveau)¶

Difficulté: Facile (ajout de fonctionnalités)

Quand faire ceci: - Passage du prototype à la production - Besoin d'accès concurrent en écriture - Nécessité de fonctionnalités SQL avancées

Étapes:

Exporter les données SQLite

# Dump en SQL
sqlite3 monapp.db .dump > backup.sql

# Ou exporter les tables individuellement
sqlite3 monapp.db -header -csv "SELECT * FROM users;" > users.csv

Régénérer le projet

create-go-starter monapp --database=postgres  # ou mysql

Convertir le schéma si nécessaire
Les migrations GORM devraient gérer la plupart des différences
Réviser et ajuster tout SQL personnalisé

Importer les données

# PostgreSQL
psql -U postgres -d monapp < converted_backup.sql

# MySQL
mysql -u root -p monapp < converted_backup.sql

Tester minutieusement
Vérifier l'intégrité des données
Tester tous les endpoints API
Exécuter la suite de tests complète

Exemples d'export/import de données¶

Export depuis PostgreSQL¶

# Dump complet de la base (compressé)
pg_dump -U postgres -h localhost -d monapp -F c -b -v -f monapp_backup.dump

# Format SQL (lisible par l'humain)
pg_dump -U postgres -h localhost -d monapp -f monapp_backup.sql

# Tables spécifiques uniquement
pg_dump -U postgres -h localhost -d monapp -t users -t posts -f partial_backup.sql

# Export CSV pour une table spécifique
psql -U postgres -d monapp -c "COPY users TO '/tmp/users.csv' WITH CSV HEADER;"

Export depuis MySQL¶

# Dump complet de la base
mysqldump -u root -p monapp > monapp_backup.sql

# Tables spécifiques uniquement
mysqldump -u root -p monapp users posts > partial_backup.sql

# Export CSV
mysql -u root -p monapp -e "SELECT * FROM users INTO OUTFILE '/tmp/users.csv'
  FIELDS TERMINATED BY ',' ENCLOSED BY '\"' LINES TERMINATED BY '\n';"

Export depuis SQLite¶

# Dump complet de la base
sqlite3 monapp.db .dump > monapp_backup.sql

# Table spécifique
sqlite3 monapp.db "SELECT * FROM users;" > users.txt

# Export CSV
sqlite3 monapp.db -header -csv "SELECT * FROM users;" > users.csv

Import vers PostgreSQL¶

# Depuis un dump PostgreSQL
pg_restore -U postgres -h localhost -d monapp monapp_backup.dump

# Depuis un fichier SQL
psql -U postgres -d monapp < monapp_backup.sql

# Depuis CSV
psql -U postgres -d monapp -c "\COPY users FROM '/tmp/users.csv' WITH CSV HEADER;"

Import vers MySQL¶

# Depuis un fichier SQL
mysql -u root -p monapp < monapp_backup.sql

# Depuis CSV
mysql -u root -p monapp -e "LOAD DATA LOCAL INFILE '/tmp/users.csv'
  INTO TABLE users
  FIELDS TERMINATED BY ','
  ENCLOSED BY '\"'
  LINES TERMINATED BY '\n'
  IGNORE 1 ROWS;"

Import vers SQLite¶

# Depuis un fichier SQL
sqlite3 monapp.db < monapp_backup.sql

# Depuis CSV
sqlite3 monapp.db <<EOF
.mode csv
.import users.csv users
EOF

Tests après migration¶

Liste de vérification: - [ ] Toutes les migrations s'exécutent avec succès - [ ] Intégrité des données vérifiée (comptages, relations) - [ ] Tous les endpoints API fonctionnent correctement - [ ] L'authentification/autorisation fonctionne - [ ] Tous les tests passent - [ ] Les performances sont acceptables - [ ] Aucune perte de données détectée

Commandes de validation:

# Exécuter tous les tests
go test ./...

# Vérifier l'intégrité des données
go run ./cmd/main.go
# Tester tous les endpoints API manuellement ou avec des tests automatisés

# Vérifier les comptages d'enregistrements
# Comparer les comptages des bases source et cible

Plan de rollback¶

Ayez toujours un plan de rollback avant de migrer:

Sauvegarder la base de données d'origine

# Garder la sauvegarde de la base d'origine en sécurité
cp monapp_backup.dump monapp_backup_SAFE.dump

Tester la migration en staging d'abord
Ne jamais tester les migrations directement en production
Utiliser un environnement de staging identique à la production
Planifier une fenêtre de maintenance
Planifier la migration pendant les périodes de faible trafic
Communiquer la maintenance aux utilisateurs

Documenter les étapes de rollback

# Exemple de script de rollback
#!/bin/bash
echo "Retour à la base de données d'origine..."
pg_restore -U postgres -h localhost -d monapp monapp_backup_SAFE.dump
echo "Rollback terminé"

Liste de vérification de migration¶

Avant la migration: - [ ] Sauvegarde complète de la base source - [ ] Sauvegarde vérifiée (test de restauration) - [ ] Environnement de staging prêt - [ ] Plan de migration documenté - [ ] Plan de rollback préparé - [ ] Maintenance planifiée - [ ] Équipe notifiée

Pendant la migration: - [ ] Arrêter l'application (empêcher les changements de données) - [ ] Exporter les données de la source - [ ] Régénérer le projet avec la nouvelle base - [ ] Importer les données vers la cible - [ ] Exécuter les migrations GORM - [ ] Vérifier l'intégrité des données

Après la migration: - [ ] Tous les tests passent - [ ] Endpoints API vérifiés - [ ] Performances acceptables - [ ] Monitoring en place - [ ] Ancienne base sauvegardée - [ ] Documentation mise à jour

Scénarios de migration courants¶

Scénario 1: Prototype vers Production¶

Chemin: SQLite → PostgreSQL

Cas d'usage: Vous avez construit un MVP avec SQLite, maintenant passage à la production.

Étapes: 1. Exporter les données SQLite 2. Régénérer avec PostgreSQL 3. Configurer PostgreSQL dans Docker/cloud 4. Importer les données 5. Tester minutieusement

Scénario 2: Hébergement partagé vers Cloud¶

Chemin: MySQL → PostgreSQL

Cas d'usage: Passage d'un hébergement partagé vers infrastructure cloud.

Étapes: 1. Exporter les données MySQL 2. Régénérer avec PostgreSQL 3. Configurer PostgreSQL managé (AWS RDS, GCP Cloud SQL) 4. Importer les données 5. Mettre à jour les chaînes de connexion

Scénario 3: Simplifier le développement¶

Chemin: PostgreSQL → SQLite

Cas d'usage: Développement local plus rapide sans Docker.

Étapes: 1. Exporter un jeu de données de test minimal 2. Régénérer avec SQLite 3. Importer les données de test 4. Garder la production sur PostgreSQL

Besoin d'aide?¶

Consulter le Guide des bases de données pour des informations détaillées
Ouvrir une issue sur GitHub
Voir les exemples dans le répertoire /examples (si disponible)

Ressources additionnelles¶

Dernière mise à jour: 2026-02-09