Просмотр исходного текста страницы Переключатели функциональности (feature toggles): виды, преимущества и работа с ними в .NET

''<blockquote>[[:Категория:Георгий Минашин (Статьи)|Георгий Минашин]], наш разработчик-эксперт, опубликовал на портале [https://habr.com/ru/top/ «Хабр»] пост о переключателях функциональности. Переключатели функциональности&nbsp;— незаменимый инструмент для разнесения во&nbsp;времени моментов публикации приложения и&nbsp;включения новой функциональности. Чем еще они могут быть полезны? Как внедрить эту технологию? Какое ПО выбрать для работы с&nbsp;переключателями в&nbsp;.NET? Об&nbsp;этом&nbsp;— в&nbsp;статье [https://habr.com/ru/company/custis/blog/463471/ «Переключатели функциональности: виды, преимущества и работа с ними в .NET»].</blockquote>''

Переключатель функциональности — это инструмент, позволяющий переключаться со&nbsp;старой функциональности на&nbsp;новую, не&nbsp;пересобирая приложение и&nbsp;не&nbsp;выпуская его заново. Реализуется добавлением в&nbsp;код условного оператора (<code>if</code>), который дает возможность управлять поведением программы, просто меняя нужное значение в&nbsp;конфигурационном файле или базе данных. Если вы хоть раз редактировали настройки в&nbsp;ini-файле, то вам знакома эта технология.

Копнув поглубже, можно обнаружить огромное количество разных вариантов переключателей и&nbsp;новых возможностей, которые они предоставляют. Это вызывает много вопросов. Где размещать конфигурацию? А&nbsp;что делать, если она станет недоступна? Наверное, можно и&nbsp;самому написать простенький каркас для работы с&nbsp;переключателями? Может, лучше взять готовое решение? А&nbsp;это подходит и&nbsp;монолиту, и&nbsp;микрослужбам?

В данном материале собрана основная информация о&nbsp;переключателях функциональности в&nbsp;контексте разработки на&nbsp;платформе .NET. В&nbsp;первой части содержатся общие сведения о&nbsp;переключателях; они достаточно независимы от&nbsp;конкретной реализации и&nbsp;могут оказаться полезными для специалистов, работающих с&nbsp;самыми разными платформами. Во&nbsp;второй части рассматриваются конкретные современные инструменты, облегчающие использование переключателей именно при разработке для .NET.

Я постарался написать статью, которая поможет решить, нужно ли внедрять переключатели функциональности в вашем конкретном случае, и&nbsp;если нужно, то&nbsp;каким образом. В&nbsp;нашем отделе переключатели пока используются только для решения частных задач. К примеру, нашему приложению часто нужно запрашивать юридическую и&nbsp;бухгалтерскую информацию из&nbsp;каталога, который может быть представлен в&nbsp;двух видах: удаленный полный каталог и&nbsp;его локальная частичная копия. В&nbsp;настройках приложения пользователи могут выбирать, с&nbsp;каталогом какого типа должно работать приложение в&nbsp;данный момент. В&nbsp;планах есть внедрение переключателей как общей инфраструктуры для целого проекта. На&nbsp;ее&nbsp;основе будут строиться процессы, подобные описанному выше.

== Общие сведения о переключателях функциональности ==

=== Что это ===
Говоря по-простому, смысл переключателей состоит в&nbsp;следующем. Исполнитель продвигается по&nbsp;нашему коду, представляющему логику предметной области, и&nbsp;натыкается на&nbsp;условный оператор. В&nbsp;этом операторе исполнитель спрашивает, нужно ли выполнять обусловленный код, у&nbsp;какого-то реестра, которому известно, когда и&nbsp;при каких обстоятельствах интересующая функциональность должна работать.
[[File:Переключатели_что это.png||600px|center]]

В результате исполнитель идет либо по&nbsp;одной ветке, либо по&nbsp;другой, а&nbsp;в&nbsp;вырожденном случае другая ветка просто пустая. В&nbsp;простейшем случае переключатель принимает одно из&nbsp;двух значений («включено» и&nbsp;«выключено») под управлением ответственного лица, которое ведет реестр. А&nbsp;можно придумать и&nbsp;что-то посложнее, например включать функциональность только для конкретных пользователей или для пользователей из&nbsp;определенных стран, или в&nbsp;определенное время.

Реестр функциональности может иметь разную форму. Смысл появляется, когда управлять этим реестром можно не&nbsp;останавливая приложение и&nbsp;не&nbsp;развертывая его заново. К&nbsp;примеру, переключатели можно хранить в&nbsp;файле, в&nbsp;базе данных или иметь отдельную сетевую службу с&nbsp;переключателями. Ниже работа переключателей рассматривается подробнее.

=== Это вообще актуально? ===
В своей [https://medium.com/@tmaslen/getting-started-with-feature-flags-fc3e617260fe статье] создатель [https://featureflag.tech/ featureflag.tech] утверждает, что переключатели становятся стандартной практикой в&nbsp;разработке ПО. Появляется все больше материалов о&nbsp;переключателях: теоретические статьи, рассказы о&nbsp;практике внедрения переключателей, доклады на&nbsp;конференциях. Я&nbsp;включил ссылки на&nbsp;самые интересные материалы в&nbsp;текст данной статьи; все ссылки собраны в&nbsp;разделе «Заключение».

Я&nbsp;сказал бы, что росту популярности переключателей способствует стабилизация и&nbsp;стандартизация в&nbsp;некоторых областях информационных технологий. В&nbsp;«кровавом энтерпрайзе» появляется все больше островков стабильности. Увеличение числа метрик в&nbsp;разработке,&nbsp;автоматизация сборки, проверки и&nbsp;доставки приложения приводят к&nbsp;тому, что процессы разработки становятся более прозрачным и&nbsp;управляемыми. В&nbsp;результате к&nbsp;созданию ПО начинают предъявляться требования нового уровня. Одним из&nbsp;таких требований оказывается желание разнести во&nbsp;времени моменты публикации приложения и&nbsp;включения новой функциональности, что и&nbsp;реализуется переключателями. Возможности отрасли уже созрели для удовлетворения этой потребности в&nbsp;промышленных масштабах.

Что касается инструментов, помогающих работать с&nbsp;переключателями, то&nbsp;их существует очень-очень много, причем для самых разных платформ. Вероятно, появление большого числа инструментов объясняется простотой, с&nbsp;которой можно реализовывать базовые возможности переключателей. Но&nbsp;добавление более сложных и&nbsp;«вкусных» плюшек может потребовать существенных трудозатрат, поэтому многие открытые проекты, реализующие переключатели функциональности, перестают развиваться и&nbsp;поддерживаться. И&nbsp;все же значительное число проектов, как платных, так и&nbsp;бесплатных, остается на&nbsp;плаву. Самые интересные из&nbsp;них (с&nbsp;точки зрения .NET) описаны во&nbsp;второй части статьи.

=== Немного подробнее ===
В [https://martinfowler.com/articles/feature-toggles.html этой заметке] есть хорошая схема, иллюстрирующая работу переключателей; предлагаю с&nbsp;ней ознакомиться.
[[File:Работа переключателей.png||600px|center]]

Начнем рассмотрение схемы с&nbsp;кода. Пусть в&nbsp;нашем примере новая функциональность&nbsp;— проверка правильности заполнения документа. Сделаем так, чтобы документ проверялся, только если эта функциональность включена. Сделаем точку переключения:

<code-csharp>var document = GetDocument();
if (feature.IsEnabled("Feature #123. Document validation"))
{
    Validate(document);
}</code-csharp>

В данном случае <code>feature</code> — это ссылка на&nbsp;инфраструктуру, помогающую нашему приложению общаться с&nbsp;маршрутизатором и&nbsp;реестром функциональности. С&nbsp;помощью данной инфраструктуры мы&nbsp;выясняем, нужно ли проверять документ, и&nbsp;если да, то проверяем его.

Маршрутизатор пользуется доступной ему информацией: названием функциональности, которое мы&nbsp;передали в&nbsp;качестве аргумента, и&nbsp;тем, что можно извлечь из&nbsp;известных ему статических классов,&nbsp;— чтобы определить, должна ли в&nbsp;данном случае работать запрошенная функциональность. Маршрутизатор выясняет, как сконфигурированы переключатели в&nbsp;реестре. Если реестр недоступен, то&nbsp;нужно либо воспользоваться ранее закэшированными данными, либо прибегнуть к&nbsp;еще какой-нибудь стратегии на&nbsp;этот случай. Также можно представить маршрутизатор, который явно через аргументы метода принимает дополнительную информацию (контекст), помогающую ему решить, включать ли в&nbsp;данный момент функциональность или нет.

Ответственные сотрудники конфигурируют переключатели выбранным способом. В&nbsp;самом приятном варианте они заходят на&nbsp;сайт, представляющий реестр переключателей, и&nbsp;мышкой щелкают по&nbsp;выбранным переключателям.

Итак, в&nbsp;смысле артефактов система переключателей состоит из&nbsp;двух частей. С&nbsp;одной стороны, это инфраструктура для программиста, позволяющая выяснить, должна ли функциональность работать в&nbsp;данном случае, и&nbsp;направлять исполнение по&nbsp;соответствующей ветке кода. С другой стороны, это механизм, позволяющий ответственному сотруднику выбирать, какую функциональность включить, а&nbsp;какую&nbsp;— выключить. В&nbsp;вырожденных случаях (когда реестр зашивается в&nbsp;код, см. ниже) оба артефакта могут совпадать, а&nbsp;программист может управлять включением и&nbsp;выключением функциональности.

=== Возможные требования к системе переключателей ===
Как видно, система переключателей может быть довольно сложной штукой. Перечислим основные требования, которые могут предъявляться к&nbsp;такой системе.

# Зависимость включения и&nbsp;выключения функциональности от&nbsp;разных параметров. Примеры параметров: пользователь (роль, идентификатор, географическое положение), время (светлое или темное время суток, рабочие или будние дни, конкретные временные промежутки), среда (для разработки, тестирования, промышленной эксплуатации).
# Сбор статистики использования при анализе процессов предметной области: какой пользователь при каких условиях увидел или не&nbsp;увидел функциональность, сколько раз воспользовались новой функциональностью.
# Аудит происходящего с&nbsp;самими переключателями: кто их нажимает, когда, что меняет.
# Предоставление гибкого выбора между локальным и&nbsp;удаленным реестром функциональности либо каких-то стратегий на случай недоступности удаленного реестра.
# Настройка доступа к&nbsp;системе переключателей для разных категорий сотрудников как у&nbsp;заказчика, так и&nbsp;у&nbsp;подрядчика: технических специалистов, специалистов в&nbsp;предметной области, а&nbsp;также самих пользователей приложения.

Разумеется, стремиться к&nbsp;удовлетворению всех этих требований не&nbsp;обязательно. Во&nbsp;многих случаях некоторые требования, наоборот, могут оказаться нежелательными. Чем больше требований надо соблюсти, тем, очевидно, более обременительной становится разработка собственной системы переключателей. Это значит, что в&nbsp;определенный момент после внедрения переключателей поддержка собственной системы становится невыгодной и&nbsp;приходит пора брать готовое решение.

=== Технологическое дерево ===
Обобщим рассмотренные сведения о&nbsp;переключателях функциональности, прибегнув к&nbsp;метафоре [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D1%80%D0%B5%D0%B2%D0%BE технологического дерева] из видеоигр. Представим переключатели как технологию, позволяющую компании выкатывать новую функциональность, не&nbsp;привязываясь к&nbsp;моментам сборки и&nbsp;развертывания приложения. У&nbsp;этой технологии есть известная стоимость (расходы на&nbsp;поддержку жизненных циклов переключателей и&nbsp;реестра) и&nbsp;предпосылки внедрения: гибкая методология разработки плюс непрерывная интеграция. Конечно, непрерывная интеграция&nbsp;— это не&nbsp;обязательная предпосылка, но&nbsp;она делает переключатели существенно более эффективными и&nbsp;позволяет обеспечить непрерывную доставку приложения. Кроме того, «исследование» переключателей «открывает» другие технологии&nbsp;— A/B-тестирование и&nbsp;канареечные выпуски. О&nbsp;них будет сказано далее.
[[File:Технологическое дерево.png||600px|center]]

=== Где может находиться реестр функциональности ===
Рассмотрим несколько вариантов размещения реестра функциональности, расположив их по&nbsp;возрастанию сложности реализации.

# Зашить конфигурацию прямо в код, например закомментировать ненужный код и раскомментировать нужный или воспользоваться директивами условной компиляции. Очевидно, этот вариант убивает суть внедрения переключателей, потому что при нем надо будет заново компилировать и развертывать приложение, чтобы увидеть новую функциональность. Еще следует отметить две трудности. Во-первых, при таком подходе от&nbsp;сотрудника, включающего функциональность, потребуются дополнительные технические навыки: редактирование исходного кода и&nbsp;умение работать с&nbsp;системой контроля версий (СКВ). Не бог весть какие навыки, конечно, но, скорее всего, включать функциональность все-таки придется самим программистам. Во-вторых, функциональность будет одинаковой на&nbsp;всех узлах, где была опубликована данная версия приложения&nbsp;— чтобы выбирать между старой и новой функциональностью, потребуется балансировщик и&nbsp;несколько узлов с&nbsp;приложением.
# Разместить конфигурацию в окружении приложения, например в&nbsp;переменных среды. Этот вариант представляется немного экстравагантным, потому что он чреват появлением излишних зависимостей от&nbsp;среды выполнения или от&nbsp;операционной системы.
# Воспользоваться конфигурационными файлами, которые являются вполне стандартным местом для хранения настроек приложения. Недостатком такого варианта будет необходимость вести конфигурационные файлы отдельно рядом с&nbsp;каждым экземпляром приложения. Этот недостаток присущ и&nbsp;предыдущему варианту.
# Вести в&nbsp;базе данных таблицу, описывающую переключатели функциональности. Экземпляры приложения будут стучаться в&nbsp;эту БД, чтобы понять, работает ли интересующая их&nbsp;функциональность. В&nbsp;этом варианте реестр централизуется (в&nbsp;отличие от предыдущего варианта), но&nbsp;оставляет возможность включать функциональность по&nbsp;отдельности для каждого узла, если это поддерживается выбранной инфраструктурой переключателей.
# Поднять сетевую службу, к&nbsp;которой экземпляры приложения будут обращаться по выбранному сетевому протоколу. Если в&nbsp;предыдущем варианте имелось в&nbsp;виду, что переключатели, скорее всего, будут храниться вместе с&nbsp;сущностями предметной области, и&nbsp;поэтому стоимость опроса переключателей будет предсказуемой, то&nbsp;здесь у&nbsp;нас будет дополнительное обращение по сети. Стоимость дополнительного обращения и&nbsp;возможность отказа службы являются серьезными недостатками этого варианта, но, конечно, кэшировать не&nbsp;запрещается. А&nbsp;для отказов надо предусмотреть поведение по&nbsp;умолчанию.

=== Рекомендации ===
Касательно использования переключателей можно дать следующие рекомендации общего характера.

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

'''Ставить точку переключения повыше.''' Развитие предыдущего пункта. Точки, в&nbsp;которых происходит обращение к&nbsp;инфраструктуре переключателей, следует до&nbsp;последней возможности исключать из&nbsp;логики предметной области, то&nbsp;есть «выпихивать» их&nbsp;поближе к&nbsp;месту приема запроса. Таким образом мы&nbsp;уменьшаем зависимость отдельных модулей от&nbsp;переключателей, упрощаем процессы их&nbsp;поддержки и&nbsp;тестирования.

'''Использовать стратегии вместо условных операторов.''' Если переключатель собирается жить долго, то условный оператор можно улучшить до&nbsp;стратегии и&nbsp;явно выделить переключаемую логику во что-то отдельно сопровождаемое и&nbsp;тестируемое.

'''Не группировать переключатели.''' Не стоит образовывать зависимости между переключателями, группировать их и&nbsp;собирать в&nbsp;иерархии. Так будет легче поддерживать и&nbsp;код с&nbsp;новой функциональностью, и&nbsp;жизненный цикл самих переключателей.

'''Консолидировать точки переключения для одной функциональности.''' Может оказаться, что поведение сразу нескольких программных блоков зависит от одного и&nbsp;того же переключателя. Если разработка плохо согласована, точки переключения могут дублироваться в разных местах, а&nbsp;это приводит к удорожанию тестирования и&nbsp;поддержки. Если дисциплинированно стараться «выталкивать» точки переключения ко&nbsp;входу в&nbsp;приложение, то&nbsp;данная рекомендация&nbsp;— не&nbsp;разбрасывать точки по&nbsp;всей системе&nbsp;— обычно выполняется автоматически.

=== Основные категории переключателей ===
Рассмотрим классификацию переключателей, приведенную в [https://martinfowler.com/articles/feature-toggles.html этой статье]. Она основана на&nbsp;том, сколько времени «живет» переключатель и как часто меняется его состояние. Отнесение переключателя к конкретному классу помогает определиться с&nbsp;тем, как использовать переключатель в&nbsp;коде и&nbsp;как хранить состояние переключателя.

==== Переключатели для выпуска ====
Это основной вид переключателей. Они позволяют сконцентрировать разработку в&nbsp;одной главной ветке, которая, к&nbsp;тому же, регулярно «выкатывается» в&nbsp;промышленную эксплуатацию. Вместо того чтобы вести разработку в&nbsp;отдельной ветке и&nbsp;вливать ее в&nbsp;главную ветку для выпуска нужной версии, мы внедряем в&nbsp;код точку переключения, которая скрывает от&nbsp;пользователей еще не&nbsp;готовую функциональность. По мере готовности переключатели запускают новую функциональность.

Такие переключатели живут несколько дней или недель&nbsp;— пока идет разработка и&nbsp;внедрение новой функциональности. Когда функциональность опробована и&nbsp;признана подходящей, переключатель и&nbsp;точку переключения в&nbsp;коде можно упразднить. Состояние переключателя обычно меняется или в момент выпуска новой версии, или при изменении конфигурации приложения. Допустимо хранить такой переключатель в&nbsp;конфигурационном файле. Существует большая вероятность, что точка переключения для новой функциональности будет единственной; имеет смысл не&nbsp;закапываться и&nbsp;оформить ее&nbsp;в&nbsp;виде обычного условного оператора.

==== Переключатели для проведения экспериментов ====
Для обкатывания новой функциональности применяются переключатели, живущие от&nbsp;нескольких дней до&nbsp;нескольких месяцев. Во&nbsp;время эксперимента можно следить за&nbsp;тем, как пользователи воспринимают изменения и&nbsp;как изменяется их&nbsp;поведение. Желательно, чтобы состояние переключателя могло меняться очень динамично, с&nbsp;каждым запросом. Сюда скорее подходит какое-то централизованное хранилище, типа БД или сетевой службы. Если эксперимент умещается в&nbsp;обозримое число выпусков, то точку переключения также можно оформить в&nbsp;виде условного оператора.

==== Технические переключатели ====
Технические переключатели помогают управлять инфраструктурными частями приложения, влияющими на&nbsp;его работу в&nbsp;целом. Они могу пригодиться, когда мы&nbsp;выкатываем обновление, влияние которого на&nbsp;производительность трудно оценить. В&nbsp;таком случае хорошо бы иметь «рубильник», мгновенно отключающий новую функциональность, если окажется, что ее использование приводит к&nbsp;катастрофическим последствиям.

Скорее всего, такие переключатели будут жить несколько недель или дольше, а&nbsp;менять состояние будут при изменении конфигурации приложения либо чаще. Критичность функции, которую реализуют эти переключатели, наводит на&nbsp;мысль, что для них надо использовать сетевую службу или хотя бы БД. Нужно начинать следить, чтобы в&nbsp;коде точки переключения для одной и&nbsp;той же функциональности не&nbsp;оказались разбросаны по&nbsp;разным местам.

==== Переключатели для разграничения доступа ====
Еще одна очевидная возможность пользоваться переключателями&nbsp;— предоставлять доступ к&nbsp;новой функциональности только некоторым пользователям. Это может понадобиться как&nbsp;для канареечного выпуска (когда новая функциональность постепенно охватывает все больше и&nbsp;больше пользователей), так и&nbsp;для создания закрытых разделов, куда имеют доступ только привилегированные пользователи.

Похоже, что такие переключатели живут довольно долго (возможно, столько же, сколько и само приложение) и&nbsp;могут менять состояние при каждом новом запросе. Здесь также подойдет сетевая служба для хранения переключателей. Рекомендуется пользоваться каким-то централизованным механизмом выбора между старой и&nbsp;новой функциональностью и&nbsp;не&nbsp;разбрасывать условные операторы по&nbsp;всему коду.

=== Интересные вещи, которые становятся проще с переключателями ===

Внедрение переключателей функциональности не только имеет явные преимущества, ради которых обычно все и&nbsp;затевается (разнесение во&nbsp;времени моментов публикации приложения и&nbsp;включения новой функциональности, уменьшение количества веток в&nbsp;СКВ), но&nbsp;также может упростить некоторые побочные процессы. Перечислим их и&nbsp;далее рассмотрим некоторые более подробно.

'''A/B-тестирование.''' Сравнение поведения пользователей, пользующихся новой и старой версиями.

'''Канареечные выпуски.''' Постепенное увеличение количества пользователей, имеющих доступ к новой функциональности.

'''Сине-зеленые выпуски.''' Направление запросов с&nbsp;помощью балансировщика либо на&nbsp;сервер со&nbsp;старой версией, либо на&nbsp;сервер с&nbsp;новой версией.

'''Плановая экстремальная функциональность.''' Включение функциональности на&nbsp;некоторый короткий промежуток времени, например во&nbsp;время проведения акции.

'''Одновременное включение функциональности в нескольких местах.''' Включение функциональности одновременно и&nbsp;на&nbsp;сайте, и&nbsp;в&nbsp;мобильном приложении. Либо включение функциональности одновременно в&nbsp;разных модулях одного и&nbsp;того же приложения. 

'''Серьезные инфраструктурные изменения.''' Например, переход к&nbsp;другому способу хранения данных.

'''Апробирование новых вещей пользователями.''' Предоставление пользователям возможности включать и&nbsp;выключать новую функциональность, настраивая приложение под себя.

==== A/B-тестирование ====
Кратко рассмотрим, что такое A/B-тестирование. При подготовке A/B-тестирования формулируется какое-то измеряемое свойство работы информационной системы или&nbsp;поведения пользователей. Примеры такого свойства: 1) продолжительность конкретного процесса предметной области, 2) относительное количество пользователей, попавших на&nbsp;конкретную страницу, 3) количество ресурсов, которыми пользуется приложение. Кроме этого делается предположение, как значение этого свойства изменится при включении новой функциональности. Будут ли пользователи быстрее получать ответ? Будут ли больше покупать? Будет ли приложение меньше «кушать»?

Затем, во&nbsp;время A/B-тестирования, для одной группы новая функциональность включается, а&nbsp;для другой&nbsp;— остается выключенной. Выдвинутое при подготовке предположение проверяется, и&nbsp;на основании результатов делается вывод о&nbsp;том, дает ли новая функциональность что-то хорошее и&nbsp;не&nbsp;приводит ли она к&nbsp;чему-то плохому. Иногда пользователей разделяют на три группы, в&nbsp;двух из&nbsp;которых функциональность остается старой. Если результаты двух контрольных групп сильно отличаются, значит, и&nbsp;весь тест содержит какую-то ошибку, делающую недостоверными выводы на&nbsp;основе этого теста.

Переключатели функциональности позволяют легко разделять пользователей на&nbsp;группы и управлять ими. Для каждой группы можно включить и&nbsp;выключить новую функциональность, не&nbsp;дожидаясь очередного выпуска приложения. Это сокращает время, которое требуется для проверки предположений и&nbsp;для прохождения всего цикла A/B-тестирования. Многие компании стремятся наладить проверку сразу нескольких предположений в&nbsp;неделю.

Подробнее об этом методе можно узнать из [https://martinfowler.com/articles/feature-toggles.html этой заметки], [https://habr.com/ru/post/323702/ здесь] и&nbsp;[https://habr.com/ru/post/445308/ здесь] на&nbsp;«Хабре», и&nbsp;еще точно стоит посмотреть [https://www.youtube.com/watch?v=UB-w1cRhcgg доклад «Feature Toggles, или Как выкатывать фичи без релиза»], где раскрываются некоторые интересные тонкости A/B-тестирования с&nbsp;переключателями функциональности.

==== Канареечные и сине-зеленые выпуски ====
При чем тут канарейки? Канарейки использовались в&nbsp;горнодобывающей промышленности: шахтеры брали канареек в клетке вместе с&nbsp;собой, когда опускались в&nbsp;шахту, где подозревалась высокая концентрация взрывоопасных газов. Канарейки очень любят чистый воздух и&nbsp;намного раньше людей начинают ощущать в&nbsp;нем вредные и&nbsp;опасные примеси. Если канарейка прекращает петь, отключается или погибает, то людям нужно срочно эвакуироваться, пока не&nbsp;рвануло. [https://www.smithsonianmag.com/smart-news/story-real-canary-coal-mine-180961570/ Вот][https://www.smithsonianmag.com/smart-news/story-real-canary-coal-mine-180961570/ здесь] можно почитать об&nbsp;этом более подробно (на английском).

Отсюда, как я понимаю, и произошло выражение «свидетельство канарейки». Если вы живете в&nbsp;государстве, проводящем репрессивную внутреннюю политику (т.&nbsp;е. в&nbsp;любом), то можете обнаружить однажды, что вам пришло распоряжение не только передать личные данные ваших пользователей уполномоченным ведомствам, но&nbsp;еще и&nbsp;не&nbsp;сообщать никому ни&nbsp;о&nbsp;том, что вы их&nbsp;сдали, ни&nbsp;о&nbsp;том, что вы получили такое распоряжение. Выкрутиться, конечно, не&nbsp;получится, но&nbsp;в&nbsp;некоторых случаях можно регулярно отправлять своим пользователям сообщения такого вида: «В&nbsp;прошедшем месяце мы&nbsp;не&nbsp;получали распоряжений о&nbsp;раскрытии ваших личных данных». Вот так вы щебечете-щебечете, как канарейка, а&nbsp;когда получаете распоряжение о&nbsp;предоставлении личных данных, [https://habr.com/ru/news/t/357040/ замолкаете]. Тем самым вы и&nbsp;исполняете требование властей, и&nbsp;даете повод вашим пользователям насторожиться.

А еще есть канареечные выпуски. Здесь метафора работает так: когда какой-то маленькой части пользователей становится плохо, мы&nbsp;срочно «эвакуируемся»&nbsp;— сворачиваем новую функциональность, из-за которой пользователям поплохело, и&nbsp;не даем ей&nbsp;охватить всех пользователей (не&nbsp;даем «рвануть»). Для этого надо иметь возможность распространять новую функциональность на&nbsp;различные группы. Здесь можно обойтись и&nbsp;без переключателей. Например, у&nbsp;нас есть балансировщик и&nbsp;два узла, куда он&nbsp;перенаправляет запросы. На&nbsp;одном узле у&nbsp;нас развернута стабильная версия, а&nbsp;на&nbsp;втором&nbsp;— экспериментальная версия, содержащая новую функциональность. По&nbsp;умолчанию все запросы отправляются на&nbsp;узел со&nbsp;стабильной версией, и&nbsp;с&nbsp;помощью балансировщика мы&nbsp;начинаем некоторые запросы отправлять на&nbsp;узел с&nbsp;экспериментальной версией.

Но с&nbsp;помощью переключателя можно добиться большей гибкости в&nbsp;том, как новая функциональность распространяется на&nbsp;пользователей. В&nbsp;переключателе можно объединить разные параметры принимаемых запросов и&nbsp;предоставить ответственным сотрудникам удобный графический интерфейс для управления канареечным выпуском. В&nbsp;целом процесс остается таким же: мы&nbsp;включаем новую функциональность для небольшой группы пользователей, например для 1&nbsp;%. После этого мы&nbsp;наблюдаем за&nbsp;состоянием приложения, за&nbsp;тем, как ведут себя пользователи, работающие с&nbsp;новой функциональностью, и&nbsp;делаем прогноз о&nbsp;том, что будет, когда мы&nbsp;распространим ее на&nbsp;большее число пользователей. Постепенно охватывая новой функциональностью все больше и&nbsp;больше пользователей, мы&nbsp;можем проверять и&nbsp;корректировать наши гипотезы. Если мы&nbsp;заметим негативные тенденции, то новую функциональность можно будет легко отключить.

Во время сине-зеленого выпуска используются два сервера, условно называемые синим и&nbsp;зеленым. Будем считать, что до&nbsp;выпуска балансировщик отправляет все запросы на&nbsp;зеленый сервер. Во&nbsp;время выпуска новая версия приложения развертывается на&nbsp;синем сервере, куда балансировщик также начинает отправлять запросы. Если оказывается, что новая версия приложения содержит ошибки, то&nbsp;мы&nbsp;переключаемся обратно на&nbsp;зеленый сервер.

Базовый вариант сине-зеленого выпуска предполагает, что пользователи либо работают со всей новой функциональностью, включенной в&nbsp;новую версию, либо не&nbsp;работают ни с никакой. А&nbsp;с&nbsp;использованием переключателей появляется возможность во&nbsp;время выпуска направить запросы на&nbsp;синий сервер с&nbsp;новой версией, для которого переключатели всей новой функциональности выключены. После этого можно постепенно включать новую функциональность по&nbsp;частям.

Можно видеть, что переключатели функциональности позволяют объединить преимущества канареечных и&nbsp;сине-зеленых выпусков. Обычно во&nbsp;время сине-зеленого выпуска имеется два четко разделенных узла со&nbsp;старой и&nbsp;новой версией приложения, и&nbsp;с&nbsp;помощью балансировщика мы&nbsp;перенаправляем сразу все запросы либо на&nbsp;один узел, либо на&nbsp;другой. А&nbsp;с&nbsp;переключателями мы&nbsp;можем перенаправить запросы на&nbsp;узел с&nbsp;новой версией, но&nbsp;с&nbsp;выключенной новой функциональностью, а&nbsp;затем постепенно включать ее, как во время канареечного выпуска.

Чуть-чуть подробнее о&nbsp;канареечных выпусках&nbsp;— в&nbsp;[https://www.martinfowler.com/bliki/CanaryRelease.html соответствующей заметке на сайте Фаулера] или на&nbsp;«Хабре», например [https://habr.com/ru/company/funcorp/blog/418329/ здесь]. О&nbsp;сине-зеленых выпусках&nbsp;— в&nbsp;[https://martinfowler.com/bliki/BlueGreenDeployment.html обзорной статье]. А&nbsp;об&nbsp;использовании переключателей функциональности в&nbsp;сине-зеленых выпусках можно почитать [http://featureflags.io/feature-flags-blue-green-deployments/ здесь].

==== Изменение способа хранения данных ====
Еще давно, при изучении таких приемов в&nbsp;программировании, как абстракция и&nbsp;разработка от&nbsp;интерфейсов, я часто встречал следующую рекомендацию: старайтесь, чтобы ваша программа не&nbsp;привязывалась к&nbsp;конкретному способу хранения данных, например, к&nbsp;определенной БД, потому что в&nbsp;будущем вам может понадобиться изменить способ хранения. Я&nbsp;это на&nbsp;ус намотал и&nbsp;делал как велено. С тех пор, однако, причины, по&nbsp;которым я&nbsp;разделяю логику предметной области и&nbsp;способ хранения, изменились, а&nbsp;к&nbsp;возможности смены БД в&nbsp;коммерческом продукте я, наоборот, начал относиться скептически.

И&nbsp;вот при подготовке данного материала я&nbsp;узнал о&nbsp;ребятах, которые [http://featureflags.io/feature-flags-database-migrations/ уверяют], что множество компаний практикует смену БД в&nbsp;промышленно эксплуатируемых продуктах. Кроме того, поменять БД якобы можно совсем безболезненно, если пользоваться переключателями функциональности. Понятно, что упомянутая статья написана людьми заинтересованными (сайт поддерживается производителем коммерческого инструмента для управления переключателями), но&nbsp;рассмотреть предложенную ими стратегию перехода на другую БД не помешает.

Вкратце описать стратегию можно так. Процесс начинается с того момента, когда наше приложение работает с&nbsp;одной (старой) БД. Пользуясь переключателями функциональности, мы&nbsp;последовательно заставляем наше приложение сначала писать данные в&nbsp;новую БД, а&nbsp;потом&nbsp;— читать данные из&nbsp;новой БД. При этом взаимодействие со&nbsp;старой БД сохраняется: мы и&nbsp;пишем, и&nbsp;читаем из&nbsp;обеих БД!

Если с&nbsp;записью все более-менее понятно, то про чтение надо пояснить. Когда приложению нужны данные, оно читает их из&nbsp;обеих БД. Эти две точки чтения всегда находятся рядом таким образом, чтобы после чтения можно было сравнить полученные данные и&nbsp;проверить их&nbsp;согласованность. После стабилизации приложения (когда обе БД начинают стабильно возвращать одинаковые данные) приложение отключается от&nbsp;старой БД, а&nbsp;переключатели удаляются.

Далее представлено подробное описание стратегии перехода к&nbsp;новой БД на&nbsp;примере MongoDB и&nbsp;DynamoDB.

В примере рассматривается переход с&nbsp;MongoDB на&nbsp;DynamoDB. При подготовке к&nbsp;переходу создается вся необходима инфраструктура для работы с&nbsp;DynamoDB: подключаются драйверы БД и&nbsp;создаются репозитории (в&nbsp;приложении) по&nbsp;аналогии с&nbsp;репозиториями MongoDB. Создаются четыре переключателя&nbsp;— по&nbsp;два для каждой БД, один из&nbsp;которых показывает, нужно ли записывать в&nbsp;эту БД, а&nbsp;второй&nbsp;— нужно ли читать из&nbsp;этой БД. С&nbsp;помощью этих переключателей далее и&nbsp;осуществляется переключение на&nbsp;новую БД (DynamoDB). 

Можно рассмотреть и&nbsp;вариант, когда часть данных должна храниться в&nbsp;MongoDB, а&nbsp;часть&nbsp;— в&nbsp;DynamoDB. Тогда группа из&nbsp;четырех переключателей заводится для каждого фрагмента данных, который предполагается изолированно переводить в&nbsp;DynamoDB (или оставлять в&nbsp;MongoDB). Далее будем считать, что мы&nbsp;переносим в&nbsp;DynamoDB все данные сразу и&nbsp;поэтому пользуемся ровно четырьмя переключателями.
[[File:Смена БД.png||600px|center]]

На&nbsp;первом этапе мы&nbsp;дублируем в&nbsp;DynamoDB все, что записывается в&nbsp;MongoDB. При этом читаем мы по-прежнему из MongoDB. Помним, что переключатели позволяют нам выбирать любые комбинации чтения и&nbsp;записи. Кроме того, у&nbsp;нас есть возможность сделать не&nbsp;бинарный переключатель («включено» и&nbsp;«выключено»), а&nbsp;более гибкий. Так что по-хорошему мы&nbsp;начинаем дублировать запись в&nbsp;DynamoDB только для небольшого числа пользователей. Постепенно увеличивая это число, мы&nbsp;наблюдаем, как себя ведут приложение и&nbsp;БД. Если что&nbsp;— останавливаемся и&nbsp;работаем над ошибками.

На втором этапе мы&nbsp;начинаем читать и&nbsp;из&nbsp;MongoDB, и&nbsp;из&nbsp;DynamoDB. В&nbsp;месте, где требуются прочитанные объекты, мы&nbsp;сравниваем данные, полученные из&nbsp;разных БД, и, если они отличаются, кидаем исключение. Либо можно выйти из&nbsp;положения как-то более изящно, например все таки отдать наружу объект, загруженный из&nbsp;MongoDB, но&nbsp;зарегистрировать ошибку чтения в&nbsp;журнале, чтобы потом с&nbsp;ней разобраться. В&nbsp;конце концов мы&nbsp;должны добиться того, чтобы объекты, получаемые из&nbsp;разных БД, были полностью идентичными. При расследовании ошибок и&nbsp;отладке нам опять помогает постепенное увеличение числа пользователей, охваченных нововведением.

На&nbsp;заключительном этапе мы&nbsp;должны как писать все данные в&nbsp;обе БД, так и&nbsp;читать данные из&nbsp;обеих БД. Чтение уже должно быть отлажено и&nbsp;настроено так, чтобы программа работала только с&nbsp;объектами, полученными из&nbsp;DynamoDB. В&nbsp;этот момент у&nbsp;нас появляется возможность отключить как запись в&nbsp;MongoDB, так и&nbsp;чтение из&nbsp;нее.

Вот и&nbsp;все. Насколько я&nbsp;понимаю, здесь, как не&nbsp;относящийся к&nbsp;теме, обойден вопрос переноса в&nbsp;DynamoDB данных, хранившихся в&nbsp;MongoDB до&nbsp;того, как мы&nbsp;начали писать в&nbsp;DynamoDB на&nbsp;100&nbsp;%. Тем не&nbsp;менее описанный прием кажется довольно интересным, особенно как пример эффективного использования переключателей при серьезных архитектурных изменениях.

==== Одновременное включение функциональности на разных платформах ====
В&nbsp;уже упомянутом докладе [https://www.youtube.com/watch?v=UB-w1cRhcgg «Feature Toggles, или Как выкатывать фичи без релиза»] рассказывалось о&nbsp;требовании включить новую функциональность одновременно (минута в&nbsp;минуту!) и&nbsp;на&nbsp;сайте, и&nbsp;в&nbsp;мобильном приложении. А&nbsp;потом еще может потребоваться выключить ее&nbsp;таким же образом.

Выполнить такое требование непросто, поскольку доставки новых версий для разных платформ очень трудно синхронизировать. Если серверы с&nbsp;сайтом находятся под вашем контролем, то здесь еще можно что-то подгадать (и&nbsp;надеяться, что в&nbsp;этот раз доставка отработает как часы), то магазин мобильных приложений может менять политику выпуска обновлений, как ему заблагорассудится. В&nbsp;любом случае обновление приложения&nbsp;— долгий процесс, который включает проверку публикуемого приложения самим магазином. Кроме того, не&nbsp;стоит надеяться, что мобильное приложение будет само регулярно запрашивать обновления у&nbsp;своего API и&nbsp;устанавливать их&nbsp;«внутри» себя. Эта лавочка, как я&nbsp;понял, тоже находится под тщательным надзором владельца платформы&nbsp;— с&nbsp;исполнением произвольного кода уж точно будут проблемы.

А вот переключатели помогают выполнить требование одновременного включения функциональности в&nbsp;условиях, когда вы не&nbsp;можете полностью контролировать доставку приложения. Очевидно, доставка все же должна гарантированно случиться до&nbsp;момента ожидаемого включения. Такой метод наверняка пригодится в&nbsp;периоды проведения временных акций, например «Черной пятницы».

Похожая ситуация и&nbsp;с&nbsp;несколькими модулями одной системы. Если они публикуются по&nbsp;отдельности и&nbsp;при этом участвуют в&nbsp;поддержке одного процесса предметной области, то&nbsp;переключатели позволяют внести согласованные изменения в&nbsp;этот процесс на&nbsp;стороне различных модулей.

== Инструменты для работы с переключателями в .NET ==
Инструменты для работы с&nbsp;переключателями можно разбить на&nbsp;три группы. Во-первых, это универсальные тяжеловесные продукты (комбайны), которые обычно включают сетевую службу, работающую у&nbsp;поставщика, и&nbsp;набор библиотек, позволяющих общаться с этой службой, для разных языков программирования. Почти всегда за&nbsp;использование таких продуктов надо платить (и&nbsp;немало). Во-вторых, это проекты, представляющие собой сетевые службы, которые надо запускать на своих компьютерах и&nbsp;к&nbsp;которым клиенты могут обращаться по&nbsp;REST API. Из проектов этой группы (для краткости будем называть их серверами) в&nbsp;обзор попали только те, у&nbsp;которых есть хорошо документированный API или официальный клиент для .NET. В-третьих, это простенькие (относительно двух предыдущих групп) библиотеки для .NET. Они предлагают хранить реестр функциональности в&nbsp;конфигурационных файлах или обращаться по&nbsp;сети к&nbsp;удаленному реестру, который не&nbsp;входит в&nbsp;состав этих проектов.

Внимательный читатель заметит, что есть еще одна группа программных средств, которая не&nbsp;попала в&nbsp;обзор. Речь идет о&nbsp;продуктах, которые можно использовать в&nbsp;виде хранилища конфигурации для распределенной системы. К&nbsp;известным представителям таких продуктов относятся [https://zookeeper.apache.org Apache ZooKeeper], [https://www.consul.io Consul] и&nbsp;[https://etcd.io etcd]. Действительно, по&nbsp;своим базовым возможностям переключатели очень схожи с&nbsp;хранилищами конфигурации, поэтому указанные инструменты можно использовать как отправную точку для создания своей инфраструктуры переключателей. Тем не&nbsp;менее из-за того, что назначение переключателей функциональности обладает определенной спецификой, с&nbsp;развитием культуры переключателей в&nbsp;рамках проекта начнут ощущаться недостатки универсальных хранилищ конфигураций. По&nbsp;этой причине подобные продукты далее не&nbsp;рассматриваются.

=== Комбайны ===

[https://launchdarkly.com '''LaunchDarkly''']

Похоже, это самый раскрученный и&nbsp;«зубодробительный» продукт в&nbsp;области переключателей функциональности. Складывается ощущение, что в&nbsp;этом продукте уместили почти все, что только может прийти в&nbsp;голову, когда говорят о&nbsp;переключателях. Это касается и&nbsp;возможностей самой платформы, и&nbsp;разнообразия доступных клиентов, и&nbsp;видов интеграции с&nbsp;разными инструментами типа Jira и&nbsp;Visual Studio Code. Все документировано очень подробно и&nbsp;с&nbsp;примерами. Инструмент, конечно, платный, но&nbsp;в&nbsp;течение пробного 30-дневного периода им можно пользоваться бесплатно.

Компания Catamorphic Co., производящая этот продукт, также опекает специальный [http://featureflags.io сайт-справочник о переключателях функциональности].

[https://rollout.io/ '''Rollout''']

Сайт выглядит мило, но&nbsp;при попытке получить конкретную информацию начинаются проблемы. Например, указано, что продукт имеет много интересных возможностей для аудита переключателей, наблюдения за&nbsp;использованием функциональности и&nbsp;проведения экспериментов. Но&nbsp;при этом производители не&nbsp;раскрывают ценовую политику (ясно только, что есть 14-дневная бесплатная пробная версия) и&nbsp;ведут довольно сырую документацию своего REST API. Документация к&nbsp;клиентским библиотекам, впрочем, в&nbsp;порядке. Система поддерживает хранение переключателей в&nbsp;конфигурационных файлах.

[https://www.optimizely.com '''Optimizely''']

В целом Optimizely&nbsp;— это какая-то крутая платформа для сбора аналитики и&nbsp;проведения экспериментов. У&nbsp;системы есть бесплатная часть [https://www.optimizely.com/rollouts/?ref=nav Rollouts], предоставляющая базовые возможности переключателей. Написано, что, кроме поддержки таргетирования («раскатывания» функциональности на&nbsp;определенные группы пользователей), эта бесплатная часть поддерживает бесконечное количество переключателей и&nbsp;проектов. Кроме того, пользоваться этой системой может сколько угодно сотрудников. Стоит отметить, что стоимость многих других продуктов определяется именно этими количественными характеристиками. Сколько будет стоить переход на&nbsp;полностью функциональную платформу&nbsp;— секрет.

[https://bullet-train.io '''Bullet train''']

Эта платформа выглядит довольно простой. Она не&nbsp;имеет каких-то особенных функций вроде сбора аналитики&nbsp;— только основные возможности переключателей. При размещении платформы на&nbsp;своих собственных серверах ею можно пользоваться бесплатно.

[https://www.split.io '''Split''']

Еще одна платформа, которая стесняется своих цен. Из&nbsp;дополнительных «фишек» предлагает интеграции с&nbsp;немногими другими инструментами разработки и&nbsp;поддержку проведения экспериментов (A/B-тестирования).

[https://configcat.com '''ConfigCat''']

А вот продукт с веселеньким сайтом, где есть котики. Выглядит задорно. Однако подозрительно, что на нем не размещена документация к REST API. С&nbsp;клиентом под .NET все в&nbsp;порядке. Кстати, есть бесплатный план.

=== Серверы ===

[https://unleash.github.io '''Unleash''']

Довольно зрелый открытый проект, который предполагает размещение системы на&nbsp;серверах компании. Включает простенький сайт для управления переключателями. Есть встроенные простейшие средства для учета использования функциональности. Установка довольно простая; требуется PostgreSQL.

Официальной клиентской библиотеки .NET не&nbsp;имеется, но уже создано несколько сторонних. Кроме того, благодаря документированному API, теоретически, можно создать свою собственную библиотеку.

[https://docs.gitlab.com/ee/user/project/operations/feature_flags.html '''GitLab feature flags''']

GitLab построил свою систему переключателей поверх Unleash, поэтому для взаимодействия с&nbsp;GitLab используются те же самые клиентские библиотеки, что и&nbsp;для Unleash. От&nbsp;самого Unleash отличается тем, что нужно меньше копаться с&nbsp;установкой (если не считать установку самого GitLab), но&nbsp;при этом нужно платить: переключатели функциональности доступны начиная с&nbsp;планов GitLab Premium (если GitLab запускается на ваших собственных серверах) и&nbsp;GitLab Silver (если GitLab запускается на&nbsp;серверах поставщика).

[https://github.com/AntoineAugusti/feature-flags '''Feature flags API in Go''']

Этот открытый проект представляет собой службу с&nbsp;API (немного документирован), через который можно управлять переключателями. Видимо, графический интерфейс отсутствует. Написан на&nbsp;Go; использует встроенные БД и&nbsp;сетевой сервер, поэтому настройка, судя по&nbsp;инструкции, тривиальна. Предоставляет зачаточные возможности для таргетирования. Последняя правка в&nbsp;репозитории: 20 февраля 2019.

[https://github.com/springernature/bandiera '''Bandiera''']

Тоже открытый проект. Служба с API и графическим интерфейсом. Написана на&nbsp;Ruby; для работы требует MySQL или PostgreSQL, либо можно поставить из&nbsp;Docker. Есть клиенты для Ruby, Node, Scala, PHP, но не для .NET. Поддерживает довольно пестрый набор видов переключателей.

[https://github.com/checkr/flagr '''Flagr''']

Еще один открытый проект на&nbsp;Go. Устанавливается из&nbsp;Docker. Есть графический интерфейс, а&nbsp;также клиенты для Ruby, Go, JavaScript, Python. Предлагает встроенные простейшие средства для учета использования функциональности и&nbsp;проведения экспериментов. Каждый переключатель можно гибко настроить и&nbsp;снабдить собственной конфигурацией.

=== Клиентские библиотеки ===
Для .NET существует огромное количество библиотек, предоставляющих основные возможности переключателей. Но&nbsp;большинство из&nbsp;них находится в&nbsp;заброшенном состоянии. Беглый обзор показал, что в&nbsp;2019 году только у&nbsp;двух проектов&nbsp;были правки в&nbsp;репозиториях. Еще два интересных проекта я&nbsp;нашёл по&nbsp;ссылкам в&nbsp;комментариях к&nbsp;данной статье. Все они представлены ниже.

'''[https://github.com/Xabaril/Esquio/ Esquio]'''

Самый интересный, хорошо документированный и&nbsp;функциональный проект своей группы. Встроенный механизм хранения — либо конфигурационный файл, либо EF&nbsp;Core. Немного интегрируется с ASP.NET&nbsp;Core (как Microsoft.FeatureManagement); в&nbsp;документации сказано, что с&nbsp;помощью Azure можно упростить конфигурирование переключателей.

[https://github.com/valdisiljuconoks/FeatureSwitch '''FeatureSwitch''']

Может запрашивать состояние переключателя и&nbsp;из&nbsp;конфигурационного файла, и&nbsp;удаленно (настраивается с помощью классов пространства FeatureSwitch.Strategies). В&nbsp;комплекте есть каркас простенького сайта, позволяющего управлять переключателями. Непонятно, есть ли возможность сделать более сложный переключатель, чем «включено/выключено».

[https://github.com/Teleopti/Toggle.Net '''Toggle.Net''']

Простейшая библиотека для работы с переключателями, которые хранит в&nbsp;текстовом файле. Видимо, поддерживает только переключатели вида «включено/выключено».

[https://github.com/ritterim/RimDev.FeatureFlags '''RimDev.FeatureFlags''']

Клиентская библиотека для ASP.NET&nbsp;Core. Помимо того, что позволяет использовать переключатели функциональности, поднимает вместе с&nbsp;основным сайтом проекта дополнительную страничку, на&nbsp;которой можно управлять переключателями. Встроенный механизм хранения конфигурации — SQL&nbsp;Server.

'''Сравнение в виде таблицы'''

Ниже инструменты из первых двух категорий (полнофункциональные системы переключателей и серверные части) собраны в таблицу для удобного сравнения.

[[File:Сравнительная таблица.PNG||700px|center]]

Содержимое колонки «Плюшки» расшифровывается примерно следующим образом.

'''Аудит.''' Инструмент ведет учет, кто, когда и как изменил состояние переключателя.

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

'''Поддержка экспериментов.''' Инструмент собирает статистику использования функциональности и некоторых параметров приложения, упрощая проведение A/B-тестирования.

'''Аналитика.''' Инструмент представляет собранную по процессам предметной области статистику в удобном для анализа виде.

'''Интеграции.''' Для инструмента налажены интеграции с другими популярными средствами разработки и управления проектами.

== Заключение ==
Похоже, что во многих компаниях уже стало обычной практикой использование переключателей для разнесения во времени моментов выпуска версии и&nbsp;включения новой функциональности. Дополнительно переключатели помогают снизить градус безумия во время слияния веток в системе контроля версий. Кроме того, они открывают дорогу к&nbsp;таким популярным методикам, как канареечные выпуски и&nbsp;A/B-тестирование.

Для работы с&nbsp;переключателями создано так много программного обеспечения, как платного, так и бесплатного, что любая компания может выбрать инструмент себе по вкусу.

В качестве итогов перечислю особенности переключателей функциональности и&nbsp;волюнтаристски (как водится) разделю их на&nbsp;преимущества и&nbsp;недостатки.

=== Преимущества ===
# Основное преимущество, которое дает внедрение переключателей — это возможность включить функциональность не во время публикации, а в любой момент после публикации версии, для которой готовилась эта функциональность.
# Чтобы откатить плохо работающую функциональность, можно просто нажать переключатель. Не надо восстанавливать старую версию всего приложения из резервной копии или из фиксации в СКВ и затрагивать все, что было опубликовано вместе с проблемной функциональностью.
# Пользуясь переключателями, разработчики более внимательно относятся к сохранению старой функциональности. Например, если система обрабатывает события и формат события меняется, то при использовании переключателя явно видны части кода, ведущие к обработчикам события как в старом формате, так и в новом. 
# Можно существенно уменьшить количество веток в СКВ, например делать отдельные ветки только для существенных изменений. В результате уменьшается количество и сложность слияний веток. Слияние как бы переносится в самое начало работы над задачей, когда нужно сделать «слияние» существующего кода и свежего переключателя. 
# Можно скорее приступить к ловле ошибок, потому что новый код становится доступным для исполнения в тестовой среде намного быстрее. Если новая функциональность затрагивает несколько систем, то с переключателями быстрее достигаются границы межсистемного взаимодействия. В результате есть возможность заранее обнаруживать непредвиденные проблемы и&nbsp;принимать такие архитектурные решения, которые стоили бы слишком дорого после продолжительной разработки.

=== Недостатки ===
# Расходы на управление жизненным циклом переключателя. Возможно, придется изменить некоторые процессы разработки и публикации. Предполагаемое решение по устранению недостатка: внедрять переключатели только там, где они действительно понадобятся. Например, не делать переключатели в небольших задачах, у которых есть четкая постановка и которые можно сделать за одну версию.
# Расходы на поддержку процессов предметной области. Например, произошла ошибка, которую нужно расследовать службе поддержки. С&nbsp;переключателями функциональности у&nbsp;службы поддержки появляется новая трудность: надо помнить, что управление могло пойти как по&nbsp;одной ветке, так и&nbsp;по&nbsp;другой, поэтому нужно определять, по&nbsp;какой именно. Предполагаемое решение по&nbsp;устранению недостатка: более детально журналировать характеристики и&nbsp;контекст запроса (включая выбранные ветки функциональности), во&nbsp;время которого произошла ошибка.
# Расходы на организационные изменения и обучение. Кто должен включать и&nbsp;выключать флаги? Кто должен помнить о том, что устаревшие флаги надо подчищать? От ответственного сотрудника могут потребоваться специальные навыки. Например, если инструмент управления переключателями собран на&nbsp;коленке и&nbsp;предназначен для технических сотрудников, то и&nbsp;пользоваться им смогут только технические сотрудники. Где хранить удаленный реестр функциональности? Как его защищать? Предполагаемое решение по устранению недостатка: пользоваться самыми простыми инструментами, поддерживающими необходимые возможности.
# Если инфраструктура переключателей — это корпоративное решение, то его надо поддерживать как отдельный проект. Если это бесплатное открытое решение, то его тоже надо поддерживать после установки на компьютеры компании. Предполагаемое решение по устранению недостатка: купить нормальное решение (шутка); не&nbsp;усложнять собственный корпоративный инструмент (пусть он поддерживает только необходимый минимум); пользоваться только самым необходимым в&nbsp;инсталляциях бесплатного открытого решения и вести собственную документацию.
# Если инфраструктура переключателей&nbsp;— это покупное решение, то надо платить денежки. Предполагаемое решение по устранению недостатка: сделать собственное корпоративное решение (шутка); выбрать решение с подходящим соотношением «функциональность/стоимость». 
# Если реестр функциональности удаленный, то будут дополнительные запросы по сети. Предполагаемое решение по&nbsp;устранению недостатка: использовать удаленный реестр только при необходимости; кэшировать состояние реестра локально (возможно, заранее).
# Дополнительная точка отказа. Что делать, если реестр функциональности недоступен? Предполагаемое решение по&nbsp;устранению недостатка: выработать стратегию на случай отказа, например писать код так, чтобы отказ реестра был ожидаем, а&nbsp;поведение по&nbsp;умолчанию было приемлемым (эта стратегия не&nbsp;всегда подходит).

== Ссылки на источники информации ==
'''Обзорные материалы'''

[https://martinfowler.com/articles/feature-toggles.html Что такое переключатели функциональности] (сайт Мартина Фаулера)

[https://medium.com/@tmaslen/getting-started-with-feature-flags-fc3e617260fe Начало работы с переключателями функциональности] (портал Medium)

[https://www.youtube.com/watch?v=UB-w1cRhcgg Как выкатывать фичи без релиза с помощью переключателей функциональности] (доклад на конференции HighLoad++)

[https://martinfowler.com/bliki/BlueGreenDeployment.html Сине-зеленые выпуски] (сайт Мартина Фаулера)

'''Использование переключателей'''

[https://habr.com/ru/post/323702/ ААБ-тестирование] («Хабр»)

[https://habr.com/ru/post/445308/ Проверка гипотез для мобильных приложений] («Хабр»)

[https://habr.com/ru/company/funcorp/blog/418329/ Безопасное тестирование в продакшене] («Хабр»)

[http://featureflags.io/feature-flags-blue-green-deployments/ Сине-зеленые выпуски] (сайт Featureflags.io)

[http://featureflags.io/feature-flags-database-migrations/ Изменение способа хранения данных] (сайт Featureflags.io)

'''Все о канарейках'''

[https://www.martinfowler.com/bliki/CanaryRelease.html Канареечные выпуски] (сайт Мартина Фаулера)

[https://www.smithsonianmag.com/smart-news/story-real-canary-coal-mine-180961570/ Использование канареек в шахтах] (журнал Smithsonian)
 
[https://habr.com/ru/news/t/357040/ Свидетельство канарейки] («Хабр»)


[[Категория:Георгий Минашин (Статьи)]]
[[Категория:Хабрахабр (Публикации)]]
[[Категория:2019 год (Статьи)]]
[[Категория:CustisWikiToLib]]