Comment configurer le processus de développement d'une base de données locale pour une petite équipe Web?


14

Contexte

Je travaille sur la création d'un nouveau processus de développement pour une petite équipe Web d'environ 4 programmeurs et 4 concepteurs, avec le potentiel évident de développer l'équipe à l'avenir. Notre produit est une application centrale qui alimente les sites Web des clients que nous concevons et hébergeons également.

Auparavant, nous travaillions tous via FTP sur un serveur de développement, avec une seule base de données de développement. Cela a "fonctionné" * pendant un certain temps, mais nous allons dans une nouvelle direction, il est donc temps de mûrir notre processus.

Nous utilisons Percona Server 5.5, mais cela devrait être indépendant de la base de données, avec l'idée de maintenir les coûts bas.

Objectifs :

Je cherche à créer un processus d'intégration continue (CI) pour le développement de bases de données en gardant à l'esprit les points suivants:

  1. Les développeurs ont une copie locale des données pour exécuter le code de développement
  2. Capable de restaurer la structure de la base de données dans un ensemble de modifications précédent
  3. Capable de séparer les modifications de schéma de nouvelles fonctionnalités des modifications de correctif de conception de schéma
  4. Capable de modifier la structure de la base de données localement pour les tests

Concept initial

J'ai esquissé un processus ci-dessous en utilisant SVN et LiquiBase, bien qu'il supprime complètement #4.

  • créer une branche «développement» à partir du tronc
  • le serveur de base de données «développement» central s'écoule de la branche «développement»
  • les développeurs locaux sont configurés comme esclaves de la branche de développement (fournit #1ci-dessus)
  • les modifications de liquibase sont régulièrement validées dans la branche de développement, qui exécute un hook post-commit pour mettre à jour la base de données de développement centrale (qui se répercutera sur les machines locales fonctionnant en tant qu'esclaves de ce serveur de développement) (liquibase fournit #2ci-dessus)
  • lorsque les fonctionnalités ou les correctifs de schéma sont prêts à passer à QA, DBA (moi) fusionnera les modifications appropriées de la branche de développement dans le tronc. Cette action créera un script sql à appliquer à un serveur de base de données intermédiaire.
  • Le serveur de transfert doit refléter TRUNK, qui doit avoir la même structure que Production, plus les modifications qui sont en QA
  • après avoir exécuté le script sql sur le serveur intermédiaire, effectuez un contrôle qualité sur les modifications.
  • Si tout semble bien, TAG la structure. Cela générera le script .sql à exécuter manuellement en production par le DBA (pour les heures creuses si nécessaire)

Ce processus nécessite que tous les développeurs utilisent la même branche de «développement», ce qui signifie qu'il n'y a qu'une seule version du schéma de base de données à un moment donné (je ne suis pas sûr que je le veuille).

Cela signifie également que toute modification du schéma ne peut pas être testée localement et pourrait affecter d'autres développeurs si elle n'est pas bien faite. Dans notre environnement, les développeurs peuvent ajouter de nouvelles tables mais rarement modifier la structure existante. En tant que DBA, les correctifs de conception sont effectués par moi. Mais l'incapacité de tester les correctifs localement est mon plus gros blocage du processus.

Comment le processus ci-dessus peut-il être modifié pour permettre le développement local, tout en conservant une copie des données relativement à jour (telle que fournie par la réplication dans le processus que je propose)? Je n'ai pas besoin que les données soient à jour jusqu'à la dernière semaine.


* Par «travaillé», je veux dire que cela suffisait mais c'était un PITA.

Réponses:


12

Gérer les environnements

Je pense que vous ne voulez certainement pas être forcé dans une seule version de base de données. Vous avez suffisamment de développeurs pour que vous ayez inévitablement plusieurs flux de travail de développement et des exigences pour appliquer des correctifs à l'environnement de production actuel, indépendamment des flux de travail de développement.

Vous pouvez utiliser Liquibase ou un processus manuel pour produire des scripts de patch pour mettre à niveau les versions. Je suggère de commencer par un processus manuel et d'utiliser l'outil de comparaison de schéma pour l'AQ sur les correctifs. Une synchronisation propre, automatisée et transparente d'une base de données non complexe est un peu utopique.

Votre modèle de données central peut être conservé dans le système qui vous convient. J'ai tout utilisé, des outils de référentiel d'entreprise fastidieux pour créer des scripts de table. Les scripts de création de table fonctionnent bien avec les outils de contrôle de source ordinaires tels que la subversion et tous les outils de référentiel ne font pas un bon travail de versioning.

Quoi que vous utilisiez comme référentiel de modèle de données maître, vous avez besoin d'un mécanisme assez propre pour déployer un environnement à partir de ce modèle. Il doit être structuré de manière à faciliter le déploiement dans un environnement. Vous avez également besoin d'un mécanisme pour patcher d'une version publiée à la suivante.

Ce que j'ai fait

J'ai fait ce qui suit dans le passé lorsque je gérais des environnements de développement. Ce n'est pas particulièrement de la haute technologie, mais il se prête au contrôle de version et aux builds automatisés, donc il est facile de déployer un environnement vers une version spécifique, et maintenir un grand nombre d'environnements est assez pratique.

Maintenir un référentiel central: il peut s'agir d'un ensemble de scripts de création de base de données conservés dans un système de contrôle de version ou d'un modèle de référentiel dans un outil de modélisation de données. Faites votre choix. Ce modèle devrait avoir un mécanisme de construction qui permet à un environnement d'être déployé à partir des scripts sans beaucoup d'intervention manuelle.

Si vous avez beaucoup de données de référence, vous aurez besoin d'un mécanisme de chargement. Selon la façon dont vous voulez le faire, vous pouvez le conserver dans une base de données ou dans un ensemble de fichiers. L'avantage des fichiers est qu'ils peuvent également être versionnés et étiquetés à partir du même système de contrôle de version que votre base de code. Un tas de fichiers CSV et de scripts de chargement en bloc dans un référentiel de contrôle de source peuvent le faire assez facilement.

Une option pour déployer des environnements de développement consiste à effectuer des sauvegardes de la base de données de production corrigées à la version appropriée et à les rendre disponibles pour les développeurs à restaurer dans un environnement de développement.

Rendez-le facile à déployer: comme tout processus de génération de CI, la base de données doit être déployable à partir d'un seul script. Configurez-le de sorte que les connexions à la base de données puissent être paramétrées, ou que le script soit indépendant de l'emplacement et puisse simplement être exécuté via la connexion.

Scripts de patch: vous aurez besoin de restaurer et probablement de restaurer les scripts de chaque version publiée.

Créez des environnements de test à partir du modèle de référentiel: cela garantit que le développement sur des environnements qui ne sont pas synchronisés avec le référentiel est pris en compte dans les tests.

Testez le processus de déploiement: les scripts de correction automatisés, quelle que soit leur création, doivent pouvoir être testés. Les outils de comparaison de schémas sont assez bons pour cela, même si vous ne les utilisez pas pour générer les scripts de patch.

  • Créez un environnement de référence avec le modèle de référentiel que vous avez testé

  • Créez un environnement de test de fumée avec une sauvegarde de votre version de production ou une version basée sur la version actuelle.

  • Exécutez le script de patch sur l'environnement de test de fumée.

  • Utilisez l'outil de comparaison de schémas pour comparer l'environnement de test de fumée avec l'environnement de référence. Le script de correctif doit avoir pour résultat que les deux bases de données sont identiques, afin que vous puissiez rechercher les différences.

Ce que j'aime dans ce processus

C'est un peu lourd et a été conçu pour être déployé dans des environnements de production assez bureaucratiques et opaques. Cependant, il présente les atouts suivants:

  • Les développeurs peuvent bricoler là où ils en ont besoin.

  • Plusieurs branches et flux de développement peuvent être adaptés.

  • Les scripts de déploiement eux-mêmes peuvent être testés de manière reproductible. Cela est très utile pour arrêter les combats de déploiement, car la répétabilité peut être démontrée.

  • Les outils de comparaison de schémas fournissent une assurance qualité sur le déploiement lui-même.

  • Les tests sont toujours effectués par rapport à ce qui devrait être publié, et cela corrigera les problèmes résultant de la désynchronisation des environnements.

  • Le déploiement basé sur des modèles de référentiel et des scripts de correctif signifie que les déchets non contrôlés ne sont pas accidentellement migrés des environnements de développement vers la production.

  • Une grande partie du processus peut être automatisée, bien qu'il soit souvent souhaitable de préparer et de tester manuellement les scripts des correctifs de déploiement.

  • Les environnements sont bon marché et faciles à déployer sans avoir à sauter à travers des cerceaux.

  • Les développeurs sont obligés de créer un système qui se prête à un processus de construction et de déploiement simple.

  • Les développeurs sont obligés d'apprendre les tâches d'administration de base de base de données, mais les environnements de test et de production sont isolés des erreurs noob.

Comment cela répond à vos besoins

  1. Les développeurs disposent d'une copie locale des données pour exécuter le code de développement par rapport aux

    scripts de déploiement ou aux images de base de données, ce qui signifie qu'ils peuvent configurer un environnement à partir de n'importe quelle version disponible.

  2. Capable de restaurer la structure de la base de données dans un ensemble de modifications précédent

    , trié par les scripts de déploiement. Que ce soit via DDL ou des images de sauvegarde de base de données de test créées via un processus contrôlé, les développeurs peuvent afficher un environnement dans n'importe quelle version spécifique que vous possédez.

  3. Capable de séparer les changements de schéma de nouvelles fonctionnalités par rapport aux changements de correctifs de conception de schéma Les

    correctifs vers une version commune peuvent être conservés dans une fourchette distincte dans l'arborescence svn. Si les sauvegardes de base de données sont utilisées comme environnements de référence, elles doivent être stockées quelque part avec la même structure de dossiers que la branche des projets de contrôle de source.

  4. Capable de modifier la structure de la base de données localement pour les tests

    Le processus de déploiement simple permet aux développeurs de bricoler et de restaurer facilement un environnement dans un état local, ou de créer un environnement de référence pour effectuer des comparaisons et effectuer des changements par rapport.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.