repositorio - ¿Cómo puedo asegurarme de que mi código de git repo es seguro?
git push example (7)
Creo que en la práctica los desarrolladores preferirán usar un repositorio central que empujar y tirar entre los repositorios locales de los demás. Una vez que hayas clonado un repositorio central, mientras trabajas en las ramas de seguimiento, ir y buscar son órdenes triviales. Agregar media docena de controles remotos a todos los repositorios locales de sus colegas es una molestia y estos repositorios 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 rama 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 repositorio 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 configuración, se encuentra en una posición 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 resto del equipo, están en el servidor central y se les hará una copia de seguridad.
Lo que requiere disciplina en ambos casos es evitar que los desarrolladores mantengan cambios de larga ejecución fuera del repositorio central. La mayoría de nosotros probablemente haya trabajado en una situación en la que un desarrollador está trabajando en la función ''x'', que necesita un cambio fundamental en algún código central. El cambio hará que todos los demás necesiten reconstruir por completo, pero la función aún no está lista 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 repositorio 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 repositorio central no debería ser muy difícil. Las sucursales locales se pueden almacenar en un espacio de nombre de etiqueta específico del desarrollador.
Por ejemplo, para Joe Bloggs, se podría hacer un alias en su repositorio local para realizar algo como lo siguiente en respuesta (por ejemplo) a git mybackup .
git push origin +refs/heads/*:refs/jbloggs/*
Este es un comando ú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? Fred puede ir a buscar las ramas 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 repositorio 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 rama central.
En el dVCS, puede suceder lo mismo, pero se debe tomar la misma decisión. Si hay un trabajo importante pero incompleto, debe guardarse centralmente. La ventaja de git es que crear esta rama central es casi trivial.
Si nuestra organización fuera a cambiar de un VCS de servidor 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 servidor central solo necesito hacer una copia de seguridad del repositorio todos los días. Si estuviéramos utilizando un DVCS, habría muchas ramas 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 copia de seguridad. .
Tenga en cuenta que no considero una buena opción "hacer que los desarrolladores empujen sucursales a un servidor": 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 servidor central nativo, entonces todo tiene que estar en el servidor central, excepto los cambios más recientes del desarrollador. Entonces, por ejemplo, si un desarrollador decide realizar una corrección de errores, esa rama se encuentra en el servidor central y está disponible para realizar una copia de seguridad 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 servidor central y está disponible para realizar una copia de seguridad hasta que el desarrollador piense: "ah, sí, debo enviar eso al servidor 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 copia de seguridad en el servidor central si estamos usando un DVCS, pero estamos con un VCS normal. ¿Cómo puedo mantener ese código seguro?
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 repositorio git común y decirle a todos que el repositorio es el oficial. Para el flujo de trabajo de desarrollo normal, los desarrolladores obtendrían cambios del repositorio común y actualizarían sus propios repositorios. Solo en el caso de dos desarrolladores que colaboran activamente en una función 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 repositorio central?
En el trabajo, tenemos una solución de respaldo que respalda los directorios de trabajo de todos los días y escribe todo el lote en un DVD semanalmente. Entonces, aunque tenemos un repositorio central, cada copia individual también se respalda.
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 repositorio en el servidor central y un trabajo en progreso en los servidores de los desarrolladores. ¿Cómo se hace una copia de seguridad del repositorio? ¿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 repositorios en los servidores de los desarrolladores son solo trabajos en progreso. ¿Quieres respaldarlo? ¡Entonces haz una copia de seguridad! Es tan simple como eso.
Tenemos un sistema de copia de seguridad automatizado que toma cualquier directorio de nuestras máquinas que especifiquemos, así que agrego todos los repositorios y copias de trabajo en mi máquina, incluidos los repositorios 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 repositorio central. Es de quien liberaste. Puede que no esté en un servidor especial; podría estar en el disco duro de algún desarrollador. Pero el repositorio que libera es el repositorio 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 repositorios 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 repositorio central, la solución es la misma: copia de seguridad 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 repositorios distribuidos en lugar de copias de trabajo de CVS o directorios rectos no versionados es irrelevante.
No es raro utilizar un servidor "central" como autoridad en DVCS, que también le proporciona el lugar para realizar sus copias de seguridad.
Puede hacer que los directorios de inicio del desarrollador monten dispositivos remotos a través de la red local. Entonces solo tiene que preocuparse por hacer que el almacenamiento en red sea seguro. O tal vez podría utilizar algo como Dropbox para copiar su repositorio local en otro lugar sin problemas.
Todos los desarrolladores de su equipo también pueden tener sus propias sucursales en el servidor (pueden ser por boleto o solo por desarrollador, etc.). De esta forma, no rompen la compilación en la rama principal, pero aún así pueden llevar su trabajo al servidor que se respalda.
Mi propia herramienta git_remote_branch puede ser útil para ese tipo de flujo de trabajo (tenga en cuenta que requiere Ruby). Ayuda a manipular ramas remotas.
Como nota al margen, hablando de seguridad repo, en su servidor puede configurar un enganche postcompromiso que haga un simple clone git o git push en otra máquina ... ¡Obtendrá una copia de seguridad actualizada después de cada confirmación!
Usamos rsync para respaldar los directorios .git de desarrolladores individuales en un directorio en el servidor. Esto se configura usando scripts de envoltura alrededor 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 tiempo de espera, si el servidor se cae o el usuario está trabajando de forma remota, todavía pueden funcionar.