¿Cómo puedo asegurarme de que mi código de git repo es seguro?

Si nuestra organización fuera a cambiar de un VCS de server central como la subversión a un VCS distribuido como git, ¿cómo me aseguro de que todo mi código esté a salvo de fallas de hardware?

Con un VCS de server central solo necesito hacer una copy de security del repository todos los días. Si estuviéramos utilizando un DVCS, habría muchas twigs de código en todas las máquinas de desarrollo, y si ese hardware fallara (o un desarrollador perdiera su computadora portátil o la robaran) entonces no tendríamos ninguna copy de security. .

Tenga en count que no considero una buena opción "hacer que los desarrolladores empujen sucursales a un server": eso es tedioso y los desarrolladores terminarán por no hacerlo.

¿Hay una forma común de resolver este problema?

Alguna aclaración:

Con un VCS de server central nativo, entonces todo tiene que estar en el server central, excepto los cambios más recientes del desarrollador. Entonces, por ejemplo, si un desarrollador decide realizar una corrección de errores, esa twig se encuentra en el server central y está disponible para realizar una copy de security de inmediato.

Si estamos usando un DVCS, entonces el desarrollador puede hacer una sucursal local (y de hecho muchas sucursales locales). Ninguna de esas sucursales está en el server central y está disponible para realizar una copy de security hasta que el desarrollador piense: "ah, sí, debo enviar eso al server central".

Así que la diferencia que estoy viendo (¡corríjanme si estoy equivocado!): Las funciones a medio implementar y las correcciones de errores probablemente no estarán disponibles para la copy de security en el server central si estamos usando un DVCS, pero estamos con un VCS normal. ¿Cómo puedo mantener ese código seguro?

Creo que en la práctica los desarrolladores preferirán usar un repository central que empujar y tirar entre los repositorys locales de los demás. Una vez que hayas clonado un repository central, mientras trabajas en las twigs de seguimiento, ir y search son órdenes triviales. Agregar media docena de controles remotos a todos los repositorys locales de sus colegas es una molestia y estos repositorys pueden no ser siempre accesibles (apagados, en una computadora portátil llevada a casa, etc.).

En algún momento, si todos están trabajando en el mismo proyecto, todo el trabajo debe estar integrado. Esto significa que necesita una twig de integración donde todos los cambios se combinen. Esto naturalmente debe ser accesible desde cualquier lugar por todos los desarrolladores, no pertenece, por ejemplo, en la computadora portátil del desarrollador principal.

Una vez que haya configurado un repository central, puede usar un flujo de trabajo de estilo cvs / svn para registrarse y actualizar. La actualización de cvs se convierte en git fetch y rebase si tienes cambios locales o simplemente git pull si no lo haces. cvs commit se convierte en git commit y git push.

Con esta configuration, se encuentra en una position similar con su sistema VCS totalmente centralizado. Una vez que los desarrolladores envían sus cambios (git push), que deben hacer para ser visibles para el rest del equipo, están en el server central y se les hará una copy de security.

Lo que requiere disciplina en ambos casos es evitar que los desarrolladores mantengan cambios de larga ejecución fuera del repository central. La mayoría de nosotros probablemente haya trabajado en una situación en la que un desarrollador está trabajando en la function 'x', que necesita un cambio fundamental en algún código central. El cambio hará que todos los demás necesiten rebuild por completo, pero la function aún no está list para la transmisión principal, por lo que solo la vigilará hasta un momento adecuado.

La situación es muy similar en ambas situaciones, aunque hay algunas diferencias prácticas. Al usar git, debido a que puede realizar confirmaciones locales y puede administrar el historial local, es posible que el desarrollador individual no sienta tanto la necesidad de ingresar al repository central como algo parecido a cvs.

Por otro lado, el uso de confirmaciones locales se puede utilizar como una ventaja. Impulsar todos los compromisos locales a un lugar seguro en el repository central no debería ser muy difícil. Las sucursales locales se pueden almacenar en un espacio de nombre de label específico del desarrollador.

Por ejemplo, para Joe Bloggs, se podría hacer un alias en su repository local para realizar algo como lo siguiente en respuesta (por ejemplo) a git mybackup .

 git push origin +refs/heads/*:refs/jbloggs/* 

Este es un command único que se puede usar en cualquier punto (como el final del día) para asegurarse de que todos sus cambios locales estén respaldados de forma segura.

Esto ayuda con todo tipo de desastres. La máquina de Joe explota y puede usar otra máquina, y guarda los commits guardados y continúa desde donde lo dejó. Joe está enfermo? Fnetworking puede ir a search las twigs de Joe para agarrar ese arreglo de 'debe tener' que hizo ayer, pero no tuvo la oportunidad de probar contra el maestro.

Para volver a la pregunta original. ¿Es necesario que haya una diferencia entre dVCS y VCS centralizado? Usted dice que las funciones a medio implementar y las correcciones de errores no terminarán en el repository central en el caso de dVCS, pero yo afirmaría que no debe haber ninguna diferencia.

He visto muchos casos en los que una característica a mitad de implementada permanece en un cuadro de trabajo de desarrolladores cuando se usa VCS centralizado. O bien adopta una política que permite que la mitad de las características escritas se registren en la secuencia principal o se debe tomar una decisión para crear una twig central.

En el dVCS, puede suceder lo mismo, pero se debe tomar la misma decisión. Si hay un trabajo importante pero incompleto, debe savese centralmente. La ventaja de git es que crear esta twig central es casi trivial.

Creo que es una falacia que usar un VCS distribuido necesariamente significa que debes usarlo de una manera completamente distribuida. Es completamente válido establecer un repository git común y decirle a todos que el repository es el oficial. Para el flujo de trabajo de desarrollo normal, los desarrolladores obtendrían cambios del repository común y actualizarían sus propios repositorys. Solo en el caso de dos desarrolladores que queueboran activamente en una function específica, es posible que necesiten extraer los cambios directamente el uno del otro.

Con más de unos pocos desarrolladores trabajando en un proyecto, sería muy tedioso tener que recordar para sacar los cambios de todos los demás. ¿Qué harías si no tuvieras un repository central?

En el trabajo, tenemos una solución de respaldo que respalda los directorys de trabajo de todos los días y escribe todo el lote en un DVD semanalmente. Entonces, aunque tenemos un repository central, cada copy individual también se respalda.

No es raro utilizar un server "central" como autoridad en DVCS, que también le proporciona el lugar para realizar sus copys de security.

Encuentro que esta pregunta es un poco extraña. Suponiendo que está utilizando un sistema de control de versiones no distribuidas, como CVS, tendrá un repository en el server central y un trabajo en progreso en los serveres de los desarrolladores. ¿Cómo se hace una copy de security del repository? ¿Cómo respaldas el trabajo de los desarrolladores en progreso? La respuesta a esas preguntas es exactamente lo que tienes que hacer para manejar tu pregunta.

Usando el control de versión distribuida, los repositorys en los serveres de los desarrolladores son solo trabajos en progreso. ¿Quieres respaldarlo? ¡Entonces haz una copy de security! Es tan simple como eso.

Tenemos un sistema de copy de security automatizado que toma cualquier directory de nuestras máquinas que especifiquemos, así que agrego todos los repositorys y copys de trabajo en mi máquina, incluidos los repositorys de git y CVS.

Por cierto, si está utilizando el control de versión distribuida en una compañía que libera un producto, entonces tendrá un repository central. Es de quien liberaste. Puede que no esté en un server especial; podría estar en el disco duro de algún desarrollador. Pero el repository que libera es el repository central. (Supongo que si aún no has lanzado, es posible que aún no tengas uno). Siento que todos los proyectos tienen uno o más repositorys centrales. (Y realmente si tienen más de uno, son dos proyectos y uno es un tenedor.) Esto también se aplica a código abierto.

Incluso si no tiene un repository central, la solución es la misma: copy de security en las máquinas del desarrollador. Deberías haber estado haciendo eso de todos modos. El hecho de que el trabajo en progreso se encuentre en repositorys distribuidos en lugar de copys de trabajo de CVS o directorys rectos no versionados es irrelevante.

Puede hacer que los directorys de inicio del desarrollador monten dispositivos remotos a través de la networking local. Entonces solo tiene que preocuparse por hacer que el almacenamiento en networking sea seguro. O tal vez podría utilizar algo como Dropbox para copyr su repository local en otro lugar sin problemas.

Todos los desarrolladores de su equipo también pueden tener sus propias sucursales en el server (pueden ser por boleto o solo por desarrollador, etc.). De esta forma, no rompen la compilation en la twig principal, pero aún así pueden llevar su trabajo al server que se respalda.

Mi propia herramienta git_remote_branch puede ser útil para ese tipo de flujo de trabajo (tenga en count que requiere Ruby). Ayuda a manipular twigs remotas.

Como nota al margen, hablando de security repo, en su server puede configurar un enganche postcompromiso que haga un simple clone git o git push en otra máquina … ¡Obtendrá una copy de security actualizada después de cada confirmación!

Usamos rsync para respaldar los directorys .git de desarrolladores individuales en un directory en el server. Esto se configura usando scripts de envoltura alnetworkingedor de git clone, y los ganchos de post-commit, etc.

Debido a que se hace en los ganchos post-*, los desarrolladores no necesitan recordar hacerlo manualmente. Y debido a que usamos rsync con un time de espera, si el server se cae o el usuario está trabajando de forma remota, todavía pueden funcionar.