svn estrategias de deployment para múltiples grupos de desarrolladores (no ubicados conjuntamente) que trabajan en diferentes componentes del mismo proyecto

Nuestro proyecto es un sistema de gestión de contenido que admite varias docenas de nuestros sitios web. El grupo de desarrollo comenzó en una location pequeña y única, y tratamos con una estrategia de encoding / implementación bastante estándar.

Codificamos fuera del tronco e insistimos en un baúl limpio. Cada pocos días labelríamos el tronco y lo desplegaríamos en el server de testing. Si todo funciona, nos desplegaríamos en Production y seguiremos adelante.

Eso funcionó bien por un time hasta que el equipo creció. Con frecuencia enfrentamos situaciones en las que la revisión labelda presentaba problemas que debían corregirse antes de pasar a Producción. Mientras el desarrollador responsable estaba trabajando en esas correcciones, teníamos otros desarrolladores que realizaban cambios en el tronco. Una vez que las correcciones del desarrollador original se completaron, los nuevos commits que se agregaron tendrían que acompañarse durante el viaje, retrasando aún más la compilation porque ahora hay una validation adicional que debe hacerse.

En un bash de rectificar esto, creamos un tronco separado utilizado estrictamente para las versiones. Las personas trabajarían en la troncal principal y luego pedirían al director del proyecto o al responsable del desarrollo que fusionen sus cambios en la troncal de publicación.

Esto funcionó por un time hasta que el equipo se hizo aún más grande y disjunta. Tenemos equipos de 3-5 personas que trabajan en 4 ubicaciones geográficas, algunas en los mismos componentes, otras en componentes diferentes con diferentes prioridades y calendars de lanzamiento. Esto fue más o less un trabajo de time completo y se convirtió en una pesadilla para la persona que administra las construcciones.

En un bash de evitarlo, comenzamos a crear "twigs de publicación" de lo que fuera la última label de producción. La gente se comprometería allí SÓLO con lo que está listo para probarse y pasar a Producción. Otros se comprometerían con el tronco hasta que fuera su turno de fusionarse. Eso tomó la carga de fusionar y resolver conflictos fuera del administrador de compilation y de la persona que posee el código.

Esto funcionó durante aproximadamente una semana hasta que comenzamos a tener que hacer varias publicaciones de "emergencia de alta prioridad". Esto efectivamente significaba que:

  1. Crear una twig fuera de la última label de Producción
  2. Agregue las cosas de emergencia a esa twig
  3. Etiquetar esa twig y lanzarla a Producción
  4. Combine todos los cambios que se realizaron en esa twig en la "twig de publicación" regular que está sentada en QA.

Esto es todos los días. Algunas veces dos veces al día.

Intenté relacionar esto un poco con un proyecto de código abierto en el que hay desarrolladores de todo el lugar que ni siquiera se conocen entre ellos y todavía parecen estar de acuerdo … pero esa comparación se desmorona cuando los nuevos estables, probados , se esperan construcciones productivas para el consumo "público" varias veces por semana (o por día). Si la compilation diaria de Firefox es un desastre con errores, por ejemplo, al less los usuarios pueden volver a una versión anterior o usar la última versión estable. Ese no es el caso para nuestros usuarios. Si nuestro lanzamiento no es perfecto, no pueden funcionar.

Trasbackground completado, ahora planteo la pregunta:

Dado un ambiente donde …

  1. Los desarrolladores están por todas partes y trabajando en diferentes componentes.
  2. Los cambios en algunos componentes pueden esperar una semana antes de su lanzamiento, otros no pueden esperar ni siquiera un día.
  3. La aplicación es de misión crítica y los cambios deben ser probados y estables antes de ser lanzados.

… ¿qué sugerencias o flujos de trabajo alternativos pueden recomendar para promover un process más seguro en el que la mayor parte de la carga no recaiga en una sola persona?

Ramas combinadas de mantenimiento y liberación

Creo que tienes requisitos similares a los de nuestra gente. Una IC lo ayudaría a automatizar, pero no resuelve el desafío organizacional subyacente.

Entonces tienes 2 types de checkins:

  • código normal no urgente (progtwigdo para su lanzamiento de vez en cuando)
  • código urgente de "revisión" (sucede después de un lanzamiento si algo se filtra sin suficientes testings o cuando llama al cliente X porque quería que el button no se viera morado y amenaza con cancelar el contrato: P)

Ambos casos son diferentes y debes separarlos. Tu enfoque ya está cerca de una respuesta, creo, pero estás haciendo "demasiado"

Déjame que te describa lo que hacemos:

Diseño de repository

trunk (is our project with components and all) branches | -- 1.0-stable-week-40 | -- 2.0-stable-week-42 | -- 3.0-stable-week-44 tags | -- 1.0.0 | -- 1.0.1 | -- 1.0.2 | -- 2.0.0 | -- 2.0.1 | -- 3.0.0 

Como puede ver, tenemos un tronco para todos los trabajos de desarrollo principales. También creamos sucursales estables para la preparación de versiones y testings cada 2 semanas y labelmos todos los lanzamientos cuando se lanzan.

Release ciclo de vida (generalizado)

Después de una nueva versión, mantenemos la twig (por ejemplo, 1.0) hasta que se lanza la siguiente versión principal. Nuestra política es que durante ese time SÓLO se puedan registrar arreglos críticos en esa sucursal. Pasan por testings mínimas solamente y pueden lanzarse en cuestión de minutos creando una nueva label de nuestra sucursal de mantenimiento.

A la mitad del período de mantenimiento (1 semana después del lanzamiento) creamos una nueva twig desde nuestro tronco llamada "2.0". Todo el desarrollo no tan urgente ya en el maletero estará en esta versión de forma automática. Se pueden agregar más cosas "con cuidado", como las correcciones urgentes que provienen de la twig de mantenimiento actualmente activa (se fusionan de 1.0 a 2.0 a la troncal).

Después de que pasó otra semana y todas las testings se realizaron, la twig 2.0 se etiquetó como 2.0.0 y se lanzó, dado que no se presentaron grandes problemas. La twig de mantenimiento 1.0 será abandonada y eliminada eventualmente.

De esta forma, podemos separar los cambios urgentes de los no urgentes y tener lanzamientos relativamente estables y sin dolor. Lo que haces es más o less lo mismo, pero te ramificas de una label que cuando terminas vuelves a labelr. Eso es un poco 🙂 La ramificación de las tags también es un mal estilo. twig de twigs.


ramas estables para lanzamiento y mantenimiento

políticas de sucursales

Ayuda al equipo si anotas la política para cada uno de tus types de twig permitiéndoles hacer más por su count sin tener a un tipo liberado sentado constantemente en su cuello y engañando sobre sus compromisos;)

Nuestras políticas podrían describirse de esta manera:

  • el maletero:

    • no se compromete con los errores de syntax
    • recibe fusiones de mantenimiento
    • no hay lanzamientos directos de esta twig
  • twigs / XX-estable

    • solo puede recibir soluciones urgentes
    • debe estar "listo para ser liberado" en todo momento
    • El desarrollador DEBE fusionar su compromiso desde aquí a cualquier twig estable más joven
    • Si no hay una twig estable más joven disponible, conéctate al tronco
  • tags / *

    • No se compromete aquí
    • utilizado para implementar

Fusionarse también se vuelve less un entrenamiento mental una vez que intentas fusionarte en una sola "dirección". (Es posible que desee search la escala de tofu de google, pero ahora está obteniendo un poco de OT). Observe que los desarrolladores realizan continuamente las fusiones y no los administradores de versiones para limitar el cuello de botella. Mientras que una versión es en vivo y se mantiene de forma activa recibiendo revisiones, ya comenzamos a preparar la siguiente, aislándola de cambios posiblemente inestables en el tronco y dándole time a "madurar".

Es posible que tenga diferentes requisitos para la duración de la incubación del código y la testing o la duración de las versiones de liberación, por supuesto. Adaptar 🙂

Soy un gran seguidor de la continuous integration junto con el desarrollo impulsado por testings.

Aquí hay algunos enlaces que recomiendo consultar:

  • CI de wikipedia
  • CruiseControl
  • Xinc – CI para PHP (mi favorito, es simple)