Автор оригинала: Jean-Paul Delimat.
Существует множество контент, описывающих какую непрерывную интеграцию, непрерывную доставку и непрерывное развертывание. Но каковы эти процессы в первую очередь?
Крайне важно понять, что проблемы CI и CD решают использовать их правильно. Это позволит вашей команде улучшить ваш процесс. И избегайте усилия, преследующие модульные метрики, которые не приносят никакого значения для вашего процесса.
Непрерывная интеграция — это командная проблема
Если вы работаете в команде, вы есть несколько разработчиков, работающих на одном репозитории. В репозитории есть главная ветвь, носящая последнюю версию кода. Разработчики работают на разных вещах на разных ветвях. Как только кто-то сделан со своими изменениями, он натолкнет или сливается на главную ветку. В конце концов вся команда потянет эту смену.
Сценарий, который мы хотим избежать, это то, что неисправный коммит делает его главной ветви. Неисправный означает код не скомпилируется, ни приложение не запускается, либо не будет. Почему? Не потому, что приложение сломано или потому что все тесты всегда должны быть зелеными. Это не проблема, вы можете очень хорошо не развернуть эту версию и ждать исправления.
Проблема в том, что вся ваша команда застряла. Все разработчики, которые потянули неисправный коммит, потратите на 5 минут, задаваясь вопросом, почему это не работает. Несколько, вероятно, попытаются найти неисправный коммит. Некоторые попытаются исправить проблему сами по себе параллельно неисправному коду автору.
Это пустая трата времени для вашей команды. Худшая часть заключается в том, что повторные инциденты топливные недоверие к главной ветви и побуждают разработчиков работать на части.
Непрерывная интеграция состоит в том, чтобы предотвратить нарушение главной ветви, чтобы ваша команда не застряла. Вот и все. Это не О том, что все ваши тесты зеленые все время и главная ветвь, развернутая для производства при каждом коммите.
Процесс непрерывной интеграции не зависит от любого инструмента. Вы могли бы проверить вручную, чтобы слияние вашей ветки и главной отрасли работает на месте. А потом только на самом деле подтолкнут сливочный репозиторий. Теперь это было бы очень неэффективно. Вот почему постоянная интеграция реализована с использованием автоматических проверок.
Проверки должны обеспечить минимальное:
- Приложение должно строить и начать
- Большинство критически важных функций должны всегда быть функциональными (регистрация пользователя/путешествие входа в систему и ключевые функции бизнеса)
- Общие слои приложения, на которых все разработчики полагаются, должны быть стабильными. Это означает, что модульные тесты на этих частях.
На практике это означает, что вам нужно потянуть любую структуру тестирования подразделения, которая работает для вас и закрепите общие слои приложения. Иногда это не так много кода и может быть сделано довольно быстро. Также вам нужно добавить «дымовой тест», подтверждающий, что код компилирует и что приложение запускается. Это особенно важно в технологиях с сумасшедшими инъекциями зависимости, такими как Java Spring или .NET CORE. В крупных проектах настолько легко запутать ваши зависимости, которые проверяют, что приложение на самом деле всегда, по крайней мере, запускается, является обязательным.
Если у вас есть сотни или тысячи тестов, вам не нужно запускать их всех для каждого слияния. Это займет много времени, и большинство тестов, вероятно, проверяют функции «une Team Blocker».
Мы увидим в следующих разделах, как процесс непрерывной доставки будет хорошо использовать эти многочисленные тесты.
Инструменты и автоматические проверки все хорошо. Но если ваши разработчики объединяют только гигантские ветви, которые они работают в течение нескольких недель, они не помогут вам. Команда будет проводить хорошее количество времени, объединяющих ветви и устранение несовместимости кода, которые возникнут в конце концов. Это так же большая пустая трата времени, как заблокировано неисправным коммитным.
Непрерывная интеграция не о инструментах. Речь идет о работе в небольших кусках и интеграция вашего нового кода к главной ветви и часто тянет.
Часто означает, по крайней мере, ежедневно. Разделите задачу, на которой вы работаете на более мелкие задачи. Объедините свой код очень часто и потяните очень часто. Таким образом, никто не работает на расстоянии больше всего дня или двух, а проблемы не успевают стать снежками.
Большая задача не должна быть все в одной ветве. Это никогда не должно быть. Методы объединения работы в прогрессе до главной отрасли называются «разветвлением по абстракции» и «Обновление функций». Смотрите блог Post Как начать с непрерывной интеграцией Больше подробностей.
Ключевые моменты для хорошей сборки CI
Это очень просто. Держать его коротким. 3-7 минут должно быть макс. Это не про ЦП и ресурсы. Речь идет о производительности разработчиков. Первое правило производительности является фокус. Делайте одну вещь, закончите его, затем перейдите к следующей вещью.
Переключение контекста дорого. Исследования показывают, что он занимает ~ 23 минуты, чтобы глубоко перефокусироваться на что-то, когда вы беспокоите. Представьте, что вы нажимаете свою ветку, чтобы объединить его. Вы начинаете другую задачу. Вы тратите 15-20 минут. В минуту После того, как вы находитесь в зоне, вы получаете уведомление «Build не удалось» из ваших 20-минутных длинных CI для предыдущей задачи. Вы вернетесь, чтобы исправить это. Вы толкаете это снова. Вы легко потеряли более 20 минут перемещения взад и вперед.
Умножьте 20 минут один или два раза в день по количеству разработчиков в вашей команде … Это много драгоценного времени впустую.
Теперь представьте себе обратную связь в течение 3 минут. И ты знал, что это бы. Вы, вероятно, не начали бы новую задачу вообще. У вас будет доказательство прочитать ваш код еще раз или рассмотреть пр во время ожидания. Неудачное уведомление придет. Вы бы это исправить. А затем перейти к следующей задаче. Это тот тип фокусировки, который должен включить ваш процесс.
Сохранение вашей CI Build Care, делает его компромисс. Тесты, которые работают дольше или обеспечивают небольшое значение в контексте CI, должны быть перемещены на шаг CD. И да, неудачи там также необходимо исправить. Но поскольку они не мешают никому сделать свою вещь, вы можете взять исправления как «следующую задачу», когда вы закончите то, что вы делаете. Просто выключите уведомления во время работы и проверки каждые время. Держите переключение контекста к минимальному.
Непрерывная доставка и развертывание являются инженерными проблемами
Давайте урегулировать определения, чтобы вытащить это с пути.
Непрерывная доставка — это возможность вообще развернуть любую версию вашего кода. На практике это означает последнюю или предварительную последнюю версию вашего кода. Вы не развертываете автоматически, обычно, обычно, потому что вам не нужно или ограничены вашим жизненным циклом проекта. Но как только кто-то чувствует, что развертывание может быть сделано в минимальном времени. Чтобы кто-то может быть командой тестов/QA, которая хочет проверить вещи на обстановке или препроводительной среде. Или на самом деле может быть время, чтобы развернуть код до производства.
Идея непрерывной доставки состоит в том, чтобы подготовить артефакты как можно ближе к тому, что вы хотите запустить в своей среде. Это могут быть баночка или файлы War, если вы работаете с Java, исполняемыми файлами, если вы работаете с .NET. Это также могут быть папки транспортированного кода JS или даже докеровских контейнеров, что бы ни делало развертывание короче (то есть вы заранее предварительно построили как можно больше).
При подготовке артефактов я не имею в виду поворотные коду в артефакты. Обычно это несколько сценариев и минут выполнения. Подготовка средств:
Запустите все тесты, которые вы можете убедиться, что когда-то развернут код будет работать на самом деле. Пропустите тесты подразделений, тесты интеграции, конец для окончания тестов и даже тесты производительности, если вы можете автоматизировать это.
Таким образом, вы можете фильтровать, какие версии вашей главной ветви на самом деле готовы и которые нет. Идеальный тестовый люкс:
- Гарантирует, что функциональные возможности ключей приложения работают. Идеально Все функциональные возможности
- Обеспечивает, что выключатель сделки с производительностью не был введен, поэтому, когда ваша новая версия ударяет ваши многие пользователи, у него есть шанс продлиться
- Сухой запуск любые обновления базы данных Ваш код должен избегать сюрпризов
Не нужно быть очень быстрым. 30 минут или 1 час приемлемы.
Непрерывное развертывание — это следующий шаг. Вы развертываете максимальную доступность и добычую версию вашего кода в некоторую среду. Идеально изготовление, если вы доверяете вашим CD Test Suite достаточно.
Обратите внимание, что в зависимости от контекста это не всегда возможно или стоит усилий. Непрерывная доставка часто достаточно, чтобы быть продуктивным. Особенно, если вы работаете в тесной сети и имеете ограниченные среды, которые вы можете развернуть. Также может быть, что цикл выпуска вашего программного обеспечения предотвращает незапланированные развертывания.
Непрерывная доставка и непрерывное развертывание (давайте назовем их CD от Never) не проблема с командой. Они о нахождении правильного баланса между временем исполнения, усилиями по техническому обслуживанию и актуальности ваших тестов, которые можно сказать «эта версия работает как она должна». И это баланс. Если ваши тесты за последние 30 часов это проблема. Посмотреть Этот эпический пост о том, как выглядит тестовый набор базы данных Oracle. Если вы тратите так много времени, сохраняя свои тесты на сегодняшний день с последним кодом, что он препятствует прогрессу команды, это тоже не хорошо. И если ваш тестовый набор гарантирует почти ничего … это в основном бесполезно.
В идеальном мире мы хотим 1 набор развертываемых артефактов в соответствии с главной веткой. Вы можете видеть, что у нас есть вертикальная проблема масштабируемости: тем быстрее мы перемещаемся от кода к артефактам, тем более готова мы должны развернуть новейшую версию кода.
Что такое большая разница?
Непрерывная интеграция — это проблема горизонтальной масштабируемости. Вы хотите разработчики объединить свой код часто, чтобы чеки должны быть быстрыми. В идеале в течение нескольких минут, чтобы избежать разрабатывателей, переключающих контекст все время с высокосинкозной обратной связью от CI Builds.
Чем больше разработчиков у вас есть, тем больше вычислительная мощность вам необходимо запустить простые чеки (сборка и тест) на всех активных ветвях.
Хорошая CI Build:
- Обеспечивает никакого кода, который нарушает базовые вещи и предотвращает работу других членов команды для работы в главной отрасли
- Достаточно быстро, чтобы обеспечить обратную связь разработчикам в течение нескольких минут, чтобы предотвратить переключение контекста между задачами
Непрерывное доставку и развертывание являются вертикальными проблемами масштабируемости. У вас есть одна довольно сложная операция для выполнения.
Хороший CD Build:
- Гарантирует, что как можно больше функций работают правильно
- Чем быстрее, тем лучше, но это не вопрос скорости. 50-60 минут сборки в порядке
Обычное заблуждение состоит в том, чтобы увидеть CD в качестве горизонтальной проблемы масштабируемости, такую как CI: тем быстрее вы можете перейти от кода к артефактам, тем больше комбинирует, что вы действительно можете обрабатывать, а ближе к идеальному сценарию вы можете быть. Но нам это не нужно. Производство артефактов для каждого фиксации и как можно быстрее, как это, как можно скорее, обычно наполняется. Вы можете очень хорошо подходить к CD на основе наилучших усилий: есть единый сборник компакт-диска, который просто выберет последний коммит для проверки после завершения данной сборки.
Не ошибиться о CD. Это действительно тяжело. Получение достаточной тестируемой уверенности, чтобы сказать, что ваше программное обеспечение готово к развернутым автоматически обычно работает на приложениях с низким уровнем поверхности, таких как APIS или простой UIS. Очень сложно достичь на сложной UI или большой монолитной системе.
Заключение
Инструменты и принципы, используемые для выполнения CI и CD, часто очень похожи. Голы очень разные, хотя.
Непрерывная интеграция представляет собой компромисс между скоростью цикла обратной связи с разработчиками и актуальностью проверки вашего выполнения (сборки и тестирование). Нет кода, который не помешает прогрессу команды, должен сделать его в главной ветви.
Непрерывная доставка развертывания связана с вами в качестве тщательной проверки, как вы можете поймать проблемы в вашем коде. Полнота чеков является наиболее важным фактором. Обычно измеряется в условиях покрытия кода или функциональным покрытием ваших испытаний. Довольны ошибками в начале предотвращения сломанного кода, чтобы развернуть в любую среду и сохраняет драгоценное время вашей тестовой команды.
Создайте свои CI и CD строят для достижения этих целей и сохраняют вашу команду продуктивной. Рабочий процесс не идеален. Проблемы произойдут каждый сейчас. Используйте их в качестве извлеченных уроков для укрепления вашего рабочего процесса каждый раз, когда они делают.
Опубликовано 27 ноября 2019 года Jean-Paul Delimat на Fire Ci Blog
Оригинал: «https://www.codementor.io/@jeanpauldelimat/the-real-difference-between-ci-and-cd-11a08304e9»