Estoy haciendo una aplicación web, y necesito hacer una bifurcación para algunos cambios importantes, la cuestión es que estos cambios requieren cambios en el esquema de la base de datos, por lo que también me gustaría poner toda la base de datos en git.
¿Cómo puedo hacer eso? ¿hay una carpeta específica que pueda guardar en un repositorio git? ¿Cómo sé cuál? ¿Cómo puedo estar seguro de que estoy colocando la carpeta correcta?
Necesito estar seguro, porque estos cambios no son compatibles con versiones anteriores; No puedo darme el lujo de meter la pata.
La base de datos en mi caso es PostgreSQL
Editar:
Alguien sugirió hacer copias de seguridad y poner el archivo de copia de seguridad bajo control de versión en lugar de la base de datos. Para ser honesto, me resulta muy difícil de tragar.
Tiene que haber una mejor manera.
Actualizar:
Bien, entonces no hay mejor manera, pero todavía no estoy muy convencido, así que cambiaré un poco la pregunta:
Me gustaría poner toda la base de datos bajo control de versiones, ¿qué motor de base de datos puedo usar para poder poner la base de datos real bajo control de versiones en lugar de su volcado?
¿Sería sqlite amigable con git?
Como este es solo el entorno de desarrollo, puedo elegir la base de datos que quiera.
Edit2:
Lo que realmente quiero no es rastrear mi historial de desarrollo, sino poder cambiar de mi rama de "nuevos cambios radicales" a la "rama estable actual" y poder, por ejemplo, solucionar algunos errores / problemas, etc., con la corriente rama estable De tal manera que cuando cambio de sucursales, la base de datos se vuelve mágicamente compatible con la sucursal en la que estoy actualmente. Realmente no me importan mucho los datos reales.
bupRespuestas:
Realice un volcado de la base de datos y controle la versión. De esta manera es un archivo de texto plano.
Personalmente, sugiero que mantenga tanto un volcado de datos como un volcado de esquema. De esta manera, usando diff se vuelve bastante fácil ver qué cambió en el esquema de una revisión a otra.
Si está haciendo grandes cambios, debe tener una base de datos secundaria en la que realice los nuevos cambios de esquema y no toque la anterior, ya que, como dijo, está haciendo una rama.
fuente
Consulte las bases de datos de refactorización ( http://databaserefactoring.com/ ) para obtener un montón de buenas técnicas para mantener su base de datos junto con los cambios de código.
Basta decir que estás haciendo las preguntas equivocadas. En lugar de poner su base de datos en git, debe descomponer sus cambios en pequeños pasos verificables para que pueda migrar / revertir los cambios de esquema con facilidad.
Si desea tener una capacidad de recuperación completa, debería considerar archivar sus registros de WAL de postgres y utilizar el PITR (recuperación en el momento) para reproducir / reenviar transacciones a estados buenos específicos conocidos.
fuente
Estoy empezando a pensar en una solución realmente simple, ¡no sé por qué no lo había pensado antes!
De esta manera, puedo cambiar de rama sin preocuparme por los cambios en el esquema de la base de datos.
EDITAR:
Por duplicado, quiero decir crear otra base de datos con un nombre diferente (como
my_db_2); No hacer un basurero ni nada de eso.fuente
Use algo como LiquiBase, esto le permite mantener el control de revisión de sus archivos Liquibase. puede etiquetar los cambios solo para producción y hacer que lb mantenga su base de datos actualizada para producción o desarrollo (o cualquier esquema que desee).
fuente
Enfrenté una necesidad similar y esto es lo que arrojó mi investigación sobre los sistemas de control de versiones de bases de datos:
fuente
ChronicDB:ChronicDB provides dynamic database upgrades with zero database downtime and inconsistencies.crunchbase.com/organization/chronicdb#section-overview Un tipo llamado Kristis Makris fue uno de los fundadores, quizás conocido por SCMBug: mkgnu.net/scmbugHay un gran proyecto llamado Migraciones bajo Doctrina que se construyó solo para este propósito.
Todavía está en estado alfa y construido para php.
http://docs.doctrine-project.org/projects/doctrine-migrations/en/latest/index.html
fuente
Me he encontrado con esta pregunta, ya que tengo un problema similar, donde algo que se aproxima a una estructura de Directorio basada en DB, almacena 'archivos', y necesito git para administrarlo. Se distribuye, a través de una nube, usando replicación, por lo tanto, su punto de acceso será a través de MySQL.
La esencia de las respuestas anteriores parece sugerir de manera similar una solución alternativa al problema planteado, que de alguna manera pierde el punto, de usar Git para administrar algo en una Base de Datos, por lo que intentaré responder esa pregunta.
Git es un sistema que, en esencia, almacena una base de datos de deltas (diferencias) que se pueden volver a ensamblar para reproducir un contexto. El uso normal de git supone que el contexto es un sistema de archivos, y esos deltas son diferencias en ese sistema de archivos, pero en realidad todo git es una base de datos jerárquica de deltas (jerárquica, porque en la mayoría de los casos cada delta es un commit con al menos 1 padres, dispuestos en un árbol).
Siempre que pueda generar un delta, en teoría, git puede almacenarlo. Normalmente, el problema es que git espera que el contexto, en el que está generando delta, sea un sistema de archivos, y de manera similar, cuando desprotege un punto en la jerarquía de git, espera generar un sistema de archivos.
Si desea gestionar el cambio, en una base de datos, tiene 2 problemas discretos, y los abordaría por separado (si fuera usted). El primero es el esquema, el segundo son los datos (aunque en su pregunta, usted indica que los datos no son algo que le preocupe). Un problema que tenía en el pasado era una base de datos de Dev y Prod, donde Dev podía realizar cambios incrementales en el esquema, y esos cambios tenían que documentarse en CVS y proponerse para vivir, junto con adiciones a uno de varios 'estáticos' mesas. Lo hicimos al tener una tercera base de datos, llamada Cruise, que contenía solo los datos estáticos. En cualquier momento, se podía comparar el esquema de Dev y Cruise, y teníamos un script para tomar la diferencia de esos 2 archivos y producir un archivo SQL que contenga sentencias ALTER, para aplicarlo. Del mismo modo, cualquier dato nuevo, podría destilarse a un archivo SQL que contenga comandos INSERT. Mientras los campos y las tablas solo se agreguen, y nunca se eliminen, el proceso podría automatizar la generación de las declaraciones SQL para aplicar el delta.
El mecanismo por el cual git genera deltas es
diffy se llama al mecanismo por el cual combina 1 o más deltas con un archivomerge. Si puede encontrar un método para diferenciarse y fusionarse desde un contexto diferente, git debería funcionar, pero como se ha discutido, puede preferir una herramienta que lo haga por usted. Mi primer pensamiento para resolver esto es esta https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration#External-Merge-and-Diff-Tools que detalla cómo reemplazar las diferencias internas y herramienta de fusión Actualizaré esta respuesta, a medida que encuentre una mejor solución al problema, pero en mi caso espero que solo tenga que administrar los cambios de datos, en la medida en que un almacén de archivos basado en DB puede cambiar, por lo que mi solución Puede que no sea exactamente lo que necesita.fuente
Eche un vistazo a RedGate SQL Source Control.
http://www.red-gate.com/products/sql-development/sql-source-control/
Esta herramienta es un complemento de SQL Server Management Studio que le permitirá colocar su base de datos bajo Control de origen con Git.
Es un poco caro a $ 495 por usuario, pero hay una prueba gratuita de 28 días disponible.
NOTA No estoy afiliado a RedGate de ninguna manera.
fuente
Quiero hacer algo similar, agregar los cambios de mi base de datos a mi sistema de control de versiones.
Voy a seguir las ideas en esta publicación de Vladimir Khorikov "Mejores prácticas de versiones de bases de datos" . En resumen lo haré
En caso de que ayude!
fuente
He estado buscando la misma característica para Postgres (o bases de datos SQL en general) por un tiempo, pero no encontré ninguna herramienta que sea lo suficientemente adecuada (simple e intuitiva). Esto probablemente se deba a la naturaleza binaria de cómo se almacenan los datos. Klonio suena ideal pero parece muerto. Noms DB se ve interesante (
y vivo). También eche un vistazo a Irmin (basado en OCaml con propiedades Git).Aunque esto no responde a la pregunta de que funcionaría con Postgres, consulte la base de datos Flur.ee. Tiene una función de "viaje en el tiempo" que le permite consultar los datos desde un punto arbitrario en el tiempo. Supongo que debería poder funcionar con un modelo "ramificado".
Esta base de datos se ha desarrollado recientemente para fines de blockchain. Debido a la naturaleza de las cadenas de bloques, los datos deben registrarse en incrementos, que es exactamente cómo funciona git. Son apuntando a un lanzamiento de código abierto en el segundo trimestre de 2019 .
Actualización : También revisa el base de datos Crux , que puede consultar a través de la dimensión de tiempo de las inserciones, que podría ver como 'versiones'. Crux parece ser una implementación de código abierto del altamente valorado Datomic.
fuente
No puede hacerlo sin atomicidad, y no puede obtener atomicidad sin usar pg_dump o un sistema de archivos de instantáneas.
Mi instancia de postgres está en zfs, que ocasionalmente tomo instantáneas. Es aproximadamente instantáneo y consistente.
fuente
Lo que quiere, en espíritu, es quizás algo así como Post Facto , que almacena versiones de una base de datos en una base de datos. Mira esta presentación .
Aparentemente, el proyecto nunca fue a ninguna parte, por lo que probablemente no lo ayudará de inmediato, pero es un concepto interesante. Me temo que hacer esto correctamente sería muy difícil, porque incluso la versión 1 tendría que obtener todos los detalles correctos para que las personas confíen en su trabajo.
fuente
He lanzado una herramienta para sqlite que hace lo que estás pidiendo. Utiliza un controlador diff personalizado que aprovecha la herramienta de proyectos sqlite 'sqldiff', los UUID como claves principales y deja fuera el sqidite rowid. Todavía está en alfa, por lo que se agradecen los comentarios.
Postgres y mysql son más complicados, ya que los datos binarios se guardan en varios archivos y es posible que ni siquiera sean válidos si pudieras capturarlos.
https://github.com/cannadayr/git-sqlite
fuente
Creo que X-Istence está en el camino correcto, pero hay algunas mejoras más que puede hacer a esta estrategia. Primer uso:
para volcar las tablas, secuencias, etc. y colocar este archivo bajo control de versiones. Lo usará para separar los cambios de compatibilidad entre sus sucursales.
A continuación, realice un volcado de datos para el conjunto de tablas que contienen la configuración requerida para que su aplicación funcione (probablemente debería omitir los datos del usuario, etc.), como los valores predeterminados del formulario y otros datos que no se pueden modificar. Puede hacer esto selectivamente usando:
Esta es una buena idea porque el repositorio puede volverse realmente torpe cuando su base de datos llega a 100Mb + cuando realiza un volcado de datos completo. Una mejor idea es hacer una copia de seguridad de un conjunto de datos más mínimo que necesita para probar su aplicación. Sin embargo, si sus datos predeterminados son muy grandes, esto puede causar problemas.
Si realmente necesita colocar copias de seguridad completas en el repositorio, considere hacerlo en una rama fuera de su árbol de origen. Sin embargo, un sistema de copia de seguridad externo con alguna referencia a la svn rev correspondiente probablemente sea lo mejor para esto.
Además, sugiero usar volcados de formato de texto sobre binario para fines de revisión (al menos para el esquema) ya que estos son más fáciles de diferenciar. Siempre puede comprimirlos para ahorrar espacio antes de registrarse.
Finalmente, eche un vistazo a la documentación de respaldo de postgres si aún no lo ha hecho. La forma en que está comentando sobre la copia de seguridad de 'la base de datos' en lugar de un volcado me hace preguntarme si está pensando en copias de seguridad basadas en el sistema de archivos (consulte la sección 23.2 para ver las advertencias).
fuente
Esta pregunta está bastante respondida, pero me gustaría complementar la respuesta de X-Istence y Dana the Sane con una pequeña sugerencia.
Si necesita control de revisión con algún grado de granularidad, digamos diariamente, puede acoplar el volcado de texto de las tablas y el esquema con una herramienta como rdiff-backup que realiza copias de seguridad incrementales. La ventaja es que en lugar de almacenar instantáneas de copias de seguridad diarias, simplemente almacena las diferencias del día anterior.
Con esto tiene la ventaja del control de revisión y no desperdicia demasiado espacio.
En cualquier caso, usar git directamente en grandes archivos planos que cambian con mucha frecuencia no es una buena solución. Si su base de datos se vuelve demasiado grande, git comenzará a tener algunos problemas para administrar los archivos.
fuente
Esto es lo que estoy tratando de hacer en mis proyectos:
La configuración de la base de datos se almacena en un archivo de configuración que no está bajo control de versiones (.gitignore)
Los valores predeterminados de la base de datos (para configurar nuevos proyectos) es un simple archivo SQL bajo control de versiones.
Para el esquema de base de datos, cree un volcado de esquema de base de datos bajo el control de versión.
La forma más común es tener scripts de actualización que contengan declaraciones SQL (ALTER Table .. o UPDATE). También debe tener un lugar en su base de datos donde guarde la versión actual de su esquema)
Eche un vistazo a otros grandes proyectos de bases de datos de código abierto (piwik, o su sistema cms favorito), todos usan guiones de actualización (1.sql, 2.sql, 3.sh, 4.php.5.sql)
Pero este es un trabajo que requiere mucho tiempo, debe crear y probar los guiones de actualización y debe ejecutar un guión de actualización común que compare la versión y ejecute todos los guiones de actualización necesarios.
Entonces, teóricamente (y eso es lo que estoy buscando), podría volcar el esquema de la base de datos después de cada cambio (manualmente, conjob, git hooks (tal vez antes de confirmar)) (y solo en algunos casos muy especiales, cree los guiones de actualización)
Después de eso en su script de actualización común (ejecute el script de actualización normal, para los casos especiales) y luego compare los esquemas (el volcado y la base de datos actual) y luego genere automáticamente las declaraciones ALTER necesarias. Hay algunas herramientas que pueden hacer esto ya, pero aún no he encontrado una buena.
fuente
Recomendaría neXtep para la versión que controla la base de datos, tiene un buen conjunto de documentación y foros que explican cómo instalar y los errores encontrados. Lo probé para postgreSQL 9.1 y 9.3, pude hacerlo funcionar para 9.1 pero para 9.3 no parece funcionar.
fuente
Lo que hago en mis proyectos personales es que almaceno toda mi base de datos en Dropbox y luego apunto el flujo de trabajo de MAMP, WAMP para usarla desde allí. De esa manera, la base de datos siempre está actualizada donde sea que necesite desarrollar. ¡Pero eso es solo para desarrolladores! ¡Los sitios en vivo están usando su propio servidor para eso por supuesto! :)
fuente
Almacenar cada nivel de cambios en la base de datos bajo el control de versiones de git es como empujar todo base de datos con cada confirmación y restaurar toda su base de datos con cada extracción. Si su base de datos es tan propensa a cambios cruciales y no puede permitirse perderlos , puede actualizar sus ganchos pre_commit y post_merge . Hice lo mismo con uno de mis proyectos y puedes encontrar las instrucciones aquí .
fuente
Así es como lo hago:
Como puede elegir libremente sobre el tipo de base de datos, utilice una base de datos basada en archivos como, por ejemplo, firebird.
Cree una base de datos de plantilla que tenga el esquema que se ajuste a su rama real y almacénela en su repositorio.
Cuando ejecute su aplicación mediante programación, cree una copia de su base de datos de plantilla, almacénela en otro lugar y simplemente trabaje con esa copia.
De esta manera, puede poner su esquema de base de datos bajo control de versiones sin los datos. Y si cambia su esquema, solo tiene que cambiar la plantilla DB
fuente
Solíamos ejecutar un sitio web social, en una configuración estándar de LAMP. Teníamos un servidor en vivo, un servidor de prueba y un servidor de desarrollo, así como las máquinas de desarrolladores locales. Todos fueron manejados usando GIT.
En cada máquina, teníamos los archivos PHP, pero también el servicio MySQL, y una carpeta con imágenes que los usuarios subirían. El servidor Live creció hasta tener unos 100K (!) Usuarios recurrentes, el volcado fue de aproximadamente 2GB (!), La carpeta Image fue de unos 50GB (!). Cuando me fui, nuestro servidor estaba llegando al límite de su CPU, Ram y, sobre todo, los límites de conexión de red concurrentes (incluso compilamos nuestra propia versión del controlador de la tarjeta de red para maximizar el servidor 'lol'). No pudimos ( ni debería suponer que con su sitio web ) poner 2GB de datos y 50GB de imágenes en GIT.
Para administrar todo esto bajo GIT fácilmente, ignoraríamos las carpetas binarias (las carpetas que contienen las Imágenes) insertando estas rutas de carpeta en .gitignore. También teníamos una carpeta llamada SQL fuera de la ruta del documentroot de Apache. En esa carpeta SQL, pondríamos nuestros archivos SQL de los desarrolladores en numeraciones incrementales (001.florianm.sql, 001.johns.sql, 002.florianm.sql, etc.). Estos archivos SQL también fueron administrados por GIT. El primer archivo sql de hecho contendría un gran conjunto de esquemas DB. No agregamos datos de usuario en GIT (por ejemplo, los registros de la tabla de usuarios o la tabla de comentarios), pero los datos como configuraciones o topología u otros datos específicos del sitio, se mantuvieron en los archivos sql (y, por lo tanto, GIT). Principalmente son los desarrolladores (que conocen mejor el código) los que determinan qué y qué no mantiene GIT con respecto al esquema y los datos SQL.
Cuando se llegó a un lanzamiento, el administrador inicia sesión en el servidor de desarrollo, fusiona la rama en vivo con todos los desarrolladores y las ramas necesarias en la máquina de desarrollo en una rama de actualización, y la envía al servidor de prueba. En el servidor de prueba, comprueba si el proceso de actualización para el servidor Live sigue siendo válido y, en una rápida sucesión, señala todo el tráfico en Apache a un sitio de marcador de posición, crea un volcado de base de datos, señala el directorio de trabajo de 'live' a 'update ', ejecuta todos los archivos sql nuevos en mysql y reenvía el tráfico al sitio correcto. Cuando todos los interesados estuvieron de acuerdo después de revisar el servidor de prueba, el administrador hizo lo mismo desde el servidor de prueba al servidor en vivo. Luego, fusiona la rama en vivo en el servidor de producción, a la rama maestra en todos los servidores, y vuelve a crear una base en todas las ramas en vivo.
Si hubo problemas en el servidor de prueba, por ejemplo. las fusiones tuvieron demasiados conflictos, luego el código fue revertido (señalando la rama de trabajo nuevamente a "en vivo") y los archivos sql nunca se ejecutaron. En el momento en que se ejecutaron los archivos sql, esto se consideró como una acción no reversible en ese momento. Si los archivos SQL no funcionaban correctamente, la base de datos se restauraba utilizando el volcado (y los desarrolladores dijeron que no, para proporcionar archivos SQL mal probados).
Hoy, mantenemos una carpeta sql-up y sql-down, con nombres de archivo equivalentes, donde los desarrolladores tienen que probar que tanto los archivos sql de actualización pueden ser degradados igualmente. En última instancia, esto podría ejecutarse con un script bash, pero es una buena idea si los ojos humanos siguen monitoreando el proceso de actualización.
No es genial, pero es manejable. Espero que esto dé una idea de un sitio de la vida real, práctico y de alta disponibilidad. Ya sea un poco anticuado, pero aún así siguió.
fuente
Utilice una herramienta como iBatis Migrations ( manual , breve video tutorial ) que le permite controlar la versión de los cambios que realiza en una base de datos a lo largo del ciclo de vida de un proyecto, en lugar de la base de datos en sí.
Esto le permite aplicar selectivamente cambios individuales a diferentes entornos, mantener un registro de cambios de los cambios en qué entornos, crear scripts para aplicar los cambios de la A a la N, revertir los cambios, etc.
fuente
Esto no depende del motor de la base de datos. Por Microsoft SQL Server hay muchos programas de control de versiones. No creo que ese problema se pueda resolver con git, debe usar un sistema de control de versión de esquema específico pgsql. No sé si tal cosa existe o no ...
fuente
Actualización 26 de agosto de 2019:
Netlify CMS lo está haciendo con GitHub, un ejemplo de implementación se puede encontrar aquí con toda la información sobre cómo lo implementaron netlify-cms-backend-github
fuente