Обработка нескольких ветвей в непрерывной интеграции

Я имел дело с проблемой масштабирования CI в моей компании и в то же время пытался выяснить, какой подход следует использовать, когда речь заходит о CI и нескольких филиалах. Аналогичный вопрос возникает в stackoverflow, нескольких ветвях функций и непрерывной интеграции. Я начал новую, потому что я хотел бы получить больше обсуждения и дать анализ в вопрос.

до сих пор я обнаружил, что есть 2 основных подхода, которые я могу принять (или, может быть, некоторые другие???).

  • несколько наборов заданий (говоря о Дженкинсе/Хадсоне здесь) на ветку
  • несколько наборов заданий на 2 ветви (dev & stable)
    • управление двумя наборами вручную (если вы измените conf задания, то обязательно измените в другой ветке)
      • Пита, но по крайней мере так мало, чтобы управление
    • другие дополнительные ветви не получат полный набор тестов, прежде чем они будут отправлены в dev
    • удовлетворены разработчиков. Почему разработчик должен заботиться о проблемах масштабирования CI. У него есть простой запрос, когда я ветвь я хотел бы проверить свой код. Простой.

Так что, похоже, если я хочу предоставить разработчикам CI для их собственных пользовательских ветвей, мне нужен специальный инструмент для Jenkins (API или shellscripts или что-то еще?) и обрабатывать масштабирование. Или я могу сказать им чаще сливаться с DEV и жить без CI на пользовательских ветвях. Какой из них вы бы взяли или есть другие варианты?

4 84
hudson jenkins continuous-integration

4 ответа:

когда вы говорите о масштабировании CI, вы действительно говорите о масштабировании использования вашего сервера CI для обработки всех ваших ветвей функций вместе с вашей магистралью. Первоначально это выглядит как хороший подход, поскольку разработчики в отрасли получают все преимущества автоматизированного тестирования, которые включают задания CI. Однако вы сталкиваетесь с проблемами управления заданиями сервера CI (как вы обнаружили) и, что более важно, вы на самом деле не делаете CI. Да, вы используете сервер CI, но это не так непрерывная интеграция кода от всех ваших разработчиков.

выполнение реального CI означает, что все ваши разработчики регулярно совершают к магистрали. Легко сказать, но трудная часть делает это, не нарушая ваше приложение. Я настоятельно рекомендую вам посмотреть Непрерывная Доставка, особенно Сохраняя Ваше Приложение Готово К Использованию на Глава 13: Управление компонентами и зависимостями. Главный пункт являются:

  • скрыть новую функциональность, пока она не будет завершена (A. K. A Характеристика Toggles).
  • внесите все изменения постепенно в виде серии небольших изменений, каждое из которых может быть выпущено.
  • используйте ветвь по абстракции для внесения крупномасштабных изменений в кодовую базу.
  • используйте компоненты для разъединения частей вашего приложения, которые изменяются с разной скоростью.

Они очень объяснительная, кроме ветви по абстракции. Это просто причудливый термин для:

  1. создайте абстракцию над той частью системы, которую вам нужно изменить.
  2. рефакторинг остальной части системы для использования уровня абстракции.
  3. создайте новую реализацию, которая не является частью пути производственного кода до завершения.
  4. обновите уровень абстракции, чтобы делегировать его новой реализации.
  5. удалить старая реализация.
  6. удалите слой абстракции, если он больше не подходит.

следующий абзац из ветви, потоки и непрерывная интеграция на Глава 14: Расширенный Контроль Версий представлены воздействий.

инкрементный подход, безусловно, требует больше дисциплины и заботы - и действительно больше творчества - чем создание ветки и дайвинг Гун-Хо в перепроектирование и разработку новых функциональных возможностей. Но это значительно снижает риск того, что ваши изменения нарушат приложение, и сэкономит вам и вашей команде много времени на слияние, исправление поломок и перевод вашего приложения в развертываемое состояние.

требуется довольно сдвиг ума, чтобы отказаться от ветвей функций, и вы всегда будете получать сопротивление. По моему опыту это сопротивление основано на том, что разработчики не чувствуют себя в безопасности, совершая код основной линии и это вполне обоснованное беспокойство. Это, в свою очередь, обычно связано с недостатком знаний, уверенности или опыта в отношении методов, перечисленных выше, и, возможно, с отсутствием уверенности в ваших автоматизированных тестах. Первое можно решить с помощью обучения и поддержки разработчиков. Последнее является гораздо более сложной проблемой, однако ветвление не обеспечивает никакой дополнительной реальной безопасности, оно просто откладывает проблему до тех пор, пока разработчики не почувствуют себя достаточно уверенно со своим кодом.

69

Я бы создал отдельные задания для каждой ветви. Я делал это раньше, и это не трудно управлять и настроить, если вы правильно настроили Hudson/Jenkins. Быстрый способ создать несколько заданий-скопировать из существующего задания, имеющего аналогичные требования, и изменить их по мере необходимости. Я не уверен, что вы хотите разрешить каждому разработчику настраивать свои собственные задания для своих собственных филиалов, но это не так много работы для одного человека (т. е. менеджера сборки). После объединения пользовательских ветвей в стабильные ветви соответствующие задания могут быть удалены, когда они больше не нужны.

Если вы беспокоитесь о нагрузке на сервер CI, вы можете настроить отдельные экземпляры CI или даже отдельные ведомые устройства, чтобы помочь сбалансировать нагрузку на нескольких серверах. Убедитесь, что сервер, на котором вы используете Hudson/Jenkins, является адекватным. Я использовал Apache Tomcat и просто должен был убедиться, что у него достаточно памяти и вычислительной мощности для обработки очереди сборки.

Это важно четко понимать, чего вы хотите достичь с помощью CI, а затем выяснить способ его реализации без особых ручных усилий или дублирования. Нет ничего плохого в использовании других внешних инструментов или сценариев, выполняемых вашим сервером CI, которые помогают упростить общий процесс управления сборкой.

4

Я бы выбрал dev + стабильные ветви. И если вы все еще хотите пользовательские ветви и боитесь нагрузки, то почему бы не переместить эти пользовательские ветви в облако и позволить разработчикам управлять ими самостоятельно, например http://cloudbees.com/dev.cb Это компании, где Kohsuke сейчас. Существует также инструмент Eclipse, поэтому, если вы находитесь на Eclipse, вы будете иметь его плотно интегрированным прямо в dev env.

3

на самом деле, что действительно проблематично, это построить изоляцию с ветвями функций. В нашей компании у нас есть набор отдельных проектов maven, все они являются частью более широкого распространения. Эти проекты поддерживаются разными командами, но для каждого дистрибутива все проекты должны быть выпущены. Теперь featurebranch может перекрываться от одного проекта к другому, и тогда изоляция сборки становится болезненной. Есть несколько решений, которые мы пробовали:

  • создать отдельный снимок репозитории в nexus для каждой ветви функций
  • общий доступ к локальным репозиториям на выделенных ведомых устройствах
  • используйте репозиторий-сервер-плагин с вышестоящими репозиториями
  • построить все в одном задании с одним частным репозиторием

в самом деле, последнее решение является наиболее перспективным. Все остальные решения так или иначе отсутствуют. Вместе с плагином job-dsl легко настроить новую ветку функций. просто скопируйте и вставьте заводной сценарий, адаптировать ветви и пусть семенное задание создать новые рабочие места. Убедитесь, что начальное задание удаляет неуправляемые задания. Затем вы можете легко масштабировать ветви функций по различным проектам maven.

но, как сказал Том выше, было бы лучше преодолеть необходимость ветвей функций и научить разработчиков интегрировать чисто, но это более длительный процесс, и результат не ясен со многими унаследованными системными частями, которые вы больше не будете касаться.

мои 2 цента

1