Процессы разработки глазами эксплуатации. Взгляд с другой стороны баррикад



    Привет, Хабр! И снова на связи Алексей Приставко.

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

    Слаженная работа этих служб — залог успешного запуска и ровного «полёта» создаваемого сервиса. Но, как показывает мой (и не только) опыт, практически ни один проект не обходится без конфликтов и разногласий, жертвой которых становится ни в чем не повинный сервис.

    В этой статье я постараюсь ответить на следующие вопросы:

    • Как методы и процессы разработки отражаются на эксплуатации?
    • Что движет каждой стороной конфликта?
    • В чем первопричина разногласий?

    Добро пожаловать под кат!

    Какие задачи стоят перед службами


    Познакомимся с отделами поближе и начнем со службы эксплуатации (она же служба поддержки). Зачем нужен этот страшный зверь, какую задачу он выполняет и «на кого» работает?

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

    Вот из чего складывается решение этой задачи:

    • Управление инцидентами: восстановление работоспособности бизнес-функции при аварии;
    • Управление проблемами: устранение вероятных причин аварий и инцидентов;
    • Управление конфигурациями: сбор информации и анализ параметров работы ПО и инфраструктуры;
    • Управление изменениями: минимизация риска возникновения проблем и аварий при изменениях.

    Роль службы разработки также понятна — первоначальное создание ИТ-сервиса и внедрение в него нового функционала по желанию заказчика.

    Наверняка, у вас уже есть подозрения по поводу точек трения разработчиков и поддержки, ведь где возникают пересечения задач, там появляются конфликты. Но не спешите с выводами. Извечные споры разработчиков и админов — это далеко не эпицентр «боёв».

    Откуда растут разногласия


    «Война» программистов и админов — это не противостояние человеческих интересов, это конфронтация служб.



    Проблема заключена в приоритетах и мотивации этих самых служб. В самом общем виде это можно описать так:

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

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

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

    • Админы активно участвуют в процессе разработки — в построении инфраструктуры, схем обеспечения отказоустойчивости и масштабируемости, в подготовке первоначальных конфигураций, а в идеале и в процессе подготовки требований к ПО. Всё это называется процессом разработки решения (не путайте с непосредственным написанием кода!).

    • Программисты активно участвуют в эксплуатации. Они исправляют программные ошибки, выполняют системные оптимизации и технические доработки для соблюдения SLA системой, то есть решают задачи доступности конечного ИТ-сервиса.

    Конфликт между программистами и админами растет из подмены понятий:

    • разработка → написание кода;
    • поддержка → администрирование прикладных сервисов.

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

    В результате программисты из отдела разработки, которых «заставляют» устранять старые баги или, не дай Бог, писать документацию, недовольны. Точно так же негодуют и админы из эксплуатации, которых просят по-быстрому подкинуть рояльчик поднять новый сервак для разработчиков или помочь им советом.

    Каждая из сторон воспринимает это не в качестве совместного решения проблемы, а как отвлечение от собственных задач, которым и без того конца и края не видно.

    Но нельзя забывать и про заказчика, ведь он, хоть и косвенно, также является участником конфликта. Как правило, ему нужно получить установленный и стабильно работающий сервис. «Голый» код, даже самый хороший, вне системы для заказчика совершенно бесполезен. У него в принципе другая картина мира:



    У стандартного заказчика нет задачи что-то создать, написать или, прости, господи, внедрить. Заказчик хочет решить бизнес-проблему с помощью волшебной кнопки «Сделать всё хорошо», в то время как IT навязывает предлагает ему конкретное решение.

    Давайте взглянем на все стороны конфликта:



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

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

    Но мы уже знаем, что обе службы не самодостаточны. Они разделены «служебной» баррикадой и при этом должны не только взаимодействовать между собой на поле передачи ответственности сообразно стадиям жизни продукта, но и активно участвовать в решении проблем друг друга.

    Другой аспект влияния заказчика — его стратегия и методология развития бизнеса. В данном случае я говорю о непонимании, как выглядит процесс разработки конкретного IT-решения. Не обладая таким пониманием, заказчик часто требует сделать из кота кита, а потом приделать ему крылья. И всегда всё срочно. Иногда это оправдано ситуацией и новаторством идеи, иногда это следствие гонки за лидером рынка и спешное копирование. Причины могут быть самые разные, но итог один.

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

    Процессы разработки


    Наконец-то мы почти добрались до того, ради чего всё затевалось. Что имеет ключевое значение для службы эксплуатации?

    1. Прозрачность выполненных доработок. Для управления изменениями необходимо понимать, что, как и зачем было сделано.
    2. Документация по логике работы и обслуживанию. В идеале — в виде инструкций. Залог соблюдения SLA — не только надежность, но и четкое понимание, что и как делать, которое должно присутствовать у всех исполнителей. «Устные знания» здесь не подходят — очень часто в эксплуатации люди работают сменами, и просто невозможно всех собрать и все объяснить. Да и память в стрессовой ситуации (а авария — это всегда стресс) может подвести.
    3. Внятная процедура передачи в поддержку новой версии с тестированием ее эксплуатационных характеристик и корректности работы функционала. По-простому — регресс и нагрузочное тестирование. Простая работоспособность нового функционала волнует эксплуатацию в наименьшей степени: команда разработки сама починит неудачный релиз по гарантии. А вот привнесенную ошибку в старом функционале эксплуатация должна если не устранить самостоятельно, то хотя бы обработать, иногда и доказать вину разработки.
    4. Возможность передать свои требования к работе нового проекта. Именно разработка закладывает важнейшие эксплуатационные характеристики. К примеру, если ПО не умеет работать в кластере — эксплуатация не сможет самостоятельно сделать его действительно надежным.

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

    Начнем с классики: модели Waterfall.

    Waterfall




    Waterfall ориентирован на доставку законченных и проработанных функциональностей. Релизная модель — циклическая. Цикл занимает от нескольких недель (крайне редко) до кварталов и полугодий. Практически всегда происходит последовательный сбор требований, их анализ, выработка архитектуры решения, оценка его длительности, планирование, полноценное регрессионное тестирование в конце.

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

    Основные проблемы Waterfall для заказчика — это продолжительность итераций и долгая стабилизация после релиза. Иногда заказчик вынужден ждать по несколько месяцев, прежде чем в продуктиве появится функционал, на создание которого достаточно недели.

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

    Каждый большой релиз сопровождается ворохом ошибок, который устраняется в период стабилизации. Обычно он превращается в ад для всех сторон — разработка вынуждена заниматься эксплуатацией, эксплуатация принимает инциденты и всеми силами «впихивает» их разработке на гарантийное устранение, а заказчик, глядя на весь этот бардак и потерянные деньги, рвет на себе волосы.

    Несмотря на всё это, с точки зрения эксплуатации, Waterfall — наиболее равномерный и предсказуемый методологический процесс, в который можно встроиться. В целом, ни продолжительность цикла, ни стабилизация эксплуатацию особенно не волнуют. Чем больше времени пройдет между релизами, тем дольше удастся спокойно поработать — а это всегда плюс. Кроме того, когда есть уверенность в том, что еще полгода ничего не поменяется, гораздо проще вписывать в процесс свои работы.

    К сожалению, очень часто заказчики настроены против Waterfall и требуют ускорить разработку проекта. В угоду этому желанию рождаются более гибкие методологии.


    Agile




    Как вы поняли, Waterfall — это очень долго, формально и влечет за собой тонны документации, на которой все и всегда халтурят. А заказчик требует всего и сразу. Как ответ на эти проблемы программисты придумали Agile манифест:

    ● Люди и взаимодействие важнее процессов и инструментов.
    Трудно с этим поспорить. Конечно, люди важнее. Но о процессах тоже не стоит забывать. Именно процессы стандартизируют и регулируют взаимодействие. К тому же, только на людях далеко не уедешь. Как минимум, человеки любят болеть, отдыхать и иногда увольняться.

    ● Работающий продукт важнее исчерпывающей документации.
    Это тоже верно. Но есть другой вопрос: а как хорошо и как долго будет работать продукт без документации? Вероятнее всего, не очень долго. А хорошо или нет —  разобраться не получится ввиду отсутствия первоисточника. И дальше придется следовать полюбившейся многим тактике «не смог разобраться — перепиши с нуля». Но это всегда долго, дорого, и вообще не факт, что результат получится лучше.

    ● Сотрудничество с заказчиком важнее согласования условий контракта.
    И снова да, важнее. Но как без согласования условий контракта мы поймем, что и как нужно сделать? Как еще преодолевать взаимное недопонимание, кроме как общаться и договариваться посредством четко прописанного документа? Конечно, контракт — тоже не панацея, но он гораздо надёжнее, чем метод из девяностых:

    — Вася, ты меня понимаешь?
    — Ну, типа да, брат.

    ● Готовность к изменениям важнее следования первоначальному плану.
    А вот это верно только в одном случае: если первоначальный план — полное бревно и то, что собирались построить, оказалось никому не нужно. Даёшь энтерпрайз-архитектора в каждые руки!

    Результат слепого следования этому манифесту — в энтерпрайз-архитектора вынужден превратиться сам бизнес-заказчик (но чаще всего от такого он превращается в тыкву). Мало того, что это не свойственный ему «функционал», так еще и в IT придется разобраться.

    SCRUM




    Scrum — это одна из первых попыток подогнать Waterfall под идеологию Agile манифеста.
    Основные черты скрама:

    • Работа короткими спринтами. Состав спринта после его начала не редактируется;
    • Планирование путем помещения отдельных User Story в журнал пожеланий спринта. На владельце проекта — выбор из «журнала проекта»;
    • Интересы заказчика представляет владелец проекта (Product Owner);
    • Команда разработки состоит из специалистов разных профилей: программисты, разработчики, архитекторы, аналитики. Команда отвечает за результат как единое целое;
    • Документацию и переписку заменяем на ежедневные обсуждения проекта всей командой.

    В теории, это достаточно здравый подход, и во многом он напоминает миниатюрную версию Waterfall. Проблемы начинают возникать на этапе реализации. К сожалению, SCRUM из-за более короткого цикла провоцирует разбивать целостную функцию на отдельные куски и доставку функции по частям еще на этапе планирования спринта.  Я молчу о том, что по этой причине всё может пойти наперекосяк уже во время «забега». Короткие спринты не оставляют времени на менеджерский запас и выкрутиться становится крайне сложно.

    В результате постоянной переприоритезации фича в готовом виде может весьма нескоро попасть в продуктив. К тому же, на этапе написания UserStory крайне сложно оценивать влияние планируемого функционала на конечную систему, так как заранее неизвестно её состояние в тот момент, когда таки появится этот функционал.

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

    Для нормальной работы эксплуатация должна:

    • Участвовать в SCRUM-встречах;
    • Постоянно быть в курсе рабочих ситуаций у разработки;
    • Знать планы разработки и статусы по релизам.

    В противном случае, успеть с приёмкой или сделать замечания будет невозможно. Конечно же, следовать всем этим пунктам у эксплуатации получается крайне редко, а если и получается, то это ведет к эскалации конфликта. Даже product-owner во время SCRUM-встречи может недальновидно проигнорировать интересы поддержки.

    Kanban




    Следующий шаг в эволюции методологий разработки — это Kanban. И без того короткие циклы SCRUM тоже показались бизнесу слишком долгими. Заказчика можно понять: всегда хочется первым получить самую крутую фишку. Да и менять планы неэффективно, получается многовато «накладных расходов».
    Так что, как говорят строители, проще «лепить по месту».

    Kanban представляет из себя IT-реализацию японской методологии бережливого производства. Но есть нюанс: в Toyota с помощью Kanban машины собирают из заранее спроектированных частей, между тем как разработка — это в первую очередь проектирование. В программировании части-функции просто копируются, их не надо постоянно «производить».

    Kanban обычно идет рука об руку с процессами CI/CD. Спринтов здесь уже нет, задачи доставляются непрерывно по мере готовности, существуют жесткие ограничения на размеры таких задач. Из-за этого сложный функционал в целостном виде не доставляется почти никогда, так как не укладывается в размер задачи.

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

    Для эксплуатации это означает невозможность обеспечить SLA: документации нет, и никто не знает, как работает система и как она должна работать.

    Предсказуемость и гарантия продолжительной работы являются основой выполнения SLA.

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

    Как это и закладывалось авторами оригинального процесса, Kanban идеален для операционной деятельности, в которой планирование заменено реакцией на раздражители. Например, так выглядит работа с инцидентами — что сломалось, то и починим. В большинстве случаев, по известной процедуре. Однако Kanban совершенно не подходит для разработки, так как слабо подразумевает конечный результат. Выбор этой методологии обречет вас на бесконечный процесс — «мы строили, строили и до сих пор строим». Не надо так!

    DevOps




    Конечно, DevOps — это не методология разработки как таковая, но я не могу не вставить свои 5 копеек и не рассказать про самую распространенную попытку решить конфликт эксплуатации и разработки.

    В теории, DevOps — это набор практик, нацеленных на активное взаимодействие специалистов по разработке со специалистами по информационно-технологическому обслуживанию и взаимную интеграцию их рабочих процессов друг в друга.

    Базируется DevOps на идее тесной взаимозависимости разработки и эксплуатации программного обеспечения и нацелен на то, чтобы помогать организациям быстрее создавать и обновлять программные продукты и услуги. Снова про быстрое создание и обновление. Но для эксплуатации этих проблем вообще не существует.

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

    На практике я чаще всего встречаю две реализации:

    • Команда админов эксплуатации сохраняется и занимается продуктивом.

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

    • То же самое, но команда эксплуатации упраздняется в духе принципа «нет человека — нет проблемы».

    Задачи управления доступностью сервиса уходят на второй план. Мотивированных на их решение людей вообще не остаётся. Периодически появляется команда DevOps-инженеров, но это ничего не меняет, так как приоритет их руководства — сроки выхода в релиз. Все прочие задачи можно задвинуть, пока никто не видит.

    Если даже вернуться к исходной идее, что DevOps — это, скорее, про тестирование, и он должен гарантировать оперативный перенос гарантированно качественных изменений, то снова окажется, что исключать из процесса или заменять эксплуатацию нельзя. Фокус самой идеи именно в обеспечении качества процесса изменений и гарантии качества этих изменений. Заметьте, нигде не говорится про соблюдение SLA и управление доступностью. Да и высокое качество изменений (компонент) вообще не гарантирует высокую эффективность работы системы в целом.

    Все предусмотреть и всё проверить невозможно — тестирование не гарантирует отсутствие аварий. Оборудование может износиться, система может выйти из строя в ходе эксплуатации в неожиданных условиях. Наконец, есть человеческий фактор.
    Поэтому даже с командой DevOps без процесса эксплуатации не обойтись, и, как ни крути, документация понадобится. Когда что-то сломается, придется разбираться, как  оно вообще работало.

    Вместо вывода


    Так что же делать и как быть?

    Бизнесу: разрабатывать внятную стратегию развития своего продукта и управлять конъюнктурой рынка, а не спешно реагировать на изменения.
    Разработке: не превращать заказчика в энтерпрайз-архитектора. Построение инженерных или ИТ-систем — не его профиль, он специалист в какой-то локальной области бизнеса.
    Всем вместе: попытки избавиться от службы эксплуатации вполне могут оказаться успешными, но вряд ли вы сможете отказаться от самого процесса эксплуатации, доступность должна оставаться под контролем. Либо этим будут управлять выделенные профессионалы, либо это будет дополнительной нагрузкой для разработчиков, решать вам.

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

    Наверняка все вы так или иначе участвовали в описанных выше ситуациях и процессах. Поделитесь своим опытом в комментариях!

    DataLine

    167,00

    Экосистема на базе дата-центров TIER III

    Поделиться публикацией
    Комментарии 26
      +1
      Для определения причин конфликтов, самое главное это понимание: никто не хочет напрягаться. А всё новое — это причина напрячься.
      Если сотрудники принимают участие в сложном запутанном процессе, но им понятен, при внесении правок в этот процесс, даже если они упрощают его, они будут сопротивляться, и от степени их сопротивления, зависит степень конфликта. С другой стороны если пользователи сами предлагают какое-то изменение, они его понимают и им не надо напрягаться. Но в этом случае придется напрягаться разработчику, чтобы понять его. И он предлагает схемы более понятные ему. Пользователю надо напрячься, чтобы понять что ему предлагают, а он этого не хочет и получаем конфликт.
      Я конечно утрирую и упрощаю, но я по своему опыту могу сказать, что с любой стороны баррикады, на любом уровне управления, никто не хочет напрягаться и это является первопричиной конфронтаций.
      Разрабу нужен софт чтобы упростить работу. Он посмотрел кучу гайдов по нему. Он ему стал понятен. Он просит админа установить. А админ об этом никогда не слышал. Надо напрячься чтобы узнать как его развернуть. Он материт разраба.
      Сотруднику тех поддержки стали прилетать новые проблемы, с которыми он не сталкивался, он винит разрабов в криворукости, потому что ему приходится напрягаться чтобы вникать в новое.
      Итак далее. Примеров можно кучу привести.
        0
        В принципе, мы пишем об этом в статье, когда говорим о дополнительной нагрузке. По моему опыту (может мне везло) я встречал людей, которым интересны их прямые обязанности и неинтересно напрягаться для других, особенно когда своих проблем хватает. В вашем примере с инструментом было бы здорово найти DevOps инженера, который тащится от помощи разработчикам в поиске и установке инструментов, тогда конфликт на этой стадии исчезнет. Но появится конфликт с эксплуатацией, которой придется напрягаться, чтобы с этим инструментом работать.
        0
        В списке не хватает SRE. Site Reliability Engineering — как раз про удаление барьера между экслпуатацией и разработкой.
          0

          Я умышленно не стал об этом писать — SRE это то, чего не хватает эксплуатации, а мы все-таки про влияние процессов разработки:-)

          0
          Что такое:
          разрабатывать внятную стратегию развития своего продукта и управлять конъюнктурой рынка

          ?

          зы
          Немного утомился от повторения фразы: DevOps (и прочие agile'ы) не про ИТ, DevOps про бизнес.
          Бизнесу важно, чтобы нашелся бы человек, который бы сказал, я беру на себя ответственность за работу вот этого (ИТ) сервиса, от начала до конца (проектирование-разработка-внедрение-эксплуатация), и все возникающие при этом вопросы я буду решать здраво, эффективно, с достижением нужного качества. Очевидно, один в поле не воин, и чтобы достичь нужной цели (работа сервиса, который создает нужную ценность, с заданными свойствами) такой человек начинает строить команду, в которой у всех, опять же, одна цель (упомянута чуть ранее). И когда админ понимает, что никому не нужн стабильный сервис, который не создает нужной ценности. И когда разраб понимает, что никому не нужен сервис с новыми классными фичами, но который не работает. Вот тогда и появляется DevOps. (да, DevOps не про pipeline'ы, тесты, контейнеры, rest, и прочее)
            0

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


            P.S. То, что Вы описываете — это и есть функционал энтерпрайз-архитектора. И да, делать надо именно так, о чем я писал выше:-)

              0
              Развивать продукт по плану — этом мечта любого бизнеса. ;)
              Некоторые бизнесы довольно неплохо прогнозируются (например, предположу что реновация Москвы детально спланирована на несколько лет вперед).
              Что делать тогда, когда планы устаревают раньше завершения их планирования? (например, вы крупный банк, и решили запилить мобильное приложения для мелких предпринимателей. что реально болит у мелких предпринимателей — вы можете только предполагать, т.к. ни вы, ни ваши коллеги из банка мелкими предпринимателями не были)
                0

                Нужно провести исследование спроса, проанализировать результаты, конкурентные предложения. Это работа для системного аналитика и опять же энтерпрайз архитектора. Промах, конечно, будет в любом случае — но вот его масштаб и глубина последствий при правильно проведенной аналитической работе значительно мньше и не столь критичны, чем В случае тыкания пальцем в небо. А значит, можно будет не спешить с корректировкой и колличество итераций будет существенно меньше. Хороший план, опять же, всегда будет иметь запас на корректировки;-)

                  +1
                  Я был неоднократным свидетелем того, как умные опытные люди долго и тщательно продумывали, планировали, запускали продукт, а после запуска выяснялось неожиданное, и в результате на ходу приходилось переобуваться (и то, потому что умные и опытные, в обратном случае продолжили бы копать по старому плану — «эффект ожидания автобуса» в действии). При этом абсолютное большинство сопричастных ИТ-ников думало: нуу тупые, не смогли очевидное предвидеть.
                  И да, вдумчиво планировать, анализировать, опрашивать, изучать и прочее нужно. Но в некоторых областях, неопределенность остается даже при всех ухищрениях планирования.
                    0
                    Конечно неопределенность будет. Но от тщательности проработки идеи будет напрямую зависеть объем и срочность корректировок. Либо мы будем находиться в процессе постоянного переделывания, либо в процессе сделали, посмотрели, немного подправили. Переделываем только в особых случаях.
                0
                Еще раз прочитал абзац про DevOps.
                Там ни слова про общую цель.

                Увы, DevOps без общей цели не работает.
                У вас могут быть автодеплои, докеры, автомониторинги, автотесты, автоконфигурации и прочее, но не быть DevOpsа.
                И наоборот, быть DevOps, и отсутствовать автодеплои, докеры, мониторинги….
                И у вас наглядные примеры тому. Когда внедряют атрибуты DevOpsа, но не сам DevOps.
                Примерно такая же история со Скрамом. Проводим дейли митинги, ретро, ператаскиваем карточки и считаем что у нас Скрам. Тогда как Скрам вертится вокруг идеи самоконтроля, саморазвития на основе непрерывной обратной связи.
                  0
                  Ну я всё-таки не разработчик и смотрю со стороны на то, как это внедряют в реальной жизни. Есть там общая цель — прекрасный продукт. Беда именно в том, что эту цель трактуют по-разному. И DevOps, где в первую очередь оно Dev, трактуют её исходя из своей системы ценностей. А у Ops она принципиально другая, о чем я и писал. И подружить одно с другим на низком уровне не получится. Надо подниматься выше, на уровень управления продуктом в целом, и там принимать взвешенные решения исходя из стратегии развития, внимательно выслушивая обе стороны. Этим должен заниматься человек с техническим прошлым как минимум. Не видел еще ни одного бизнесс-заказчика, который бы понимал важность и последствия тех или иных технических решений. Т.е. управлять конфликтом, балансируя интересы сторон на благо продукта и объясняя почему было решено именно так.
              0
              Цинично отмечу, что «служба эксплуатации» это не первая, а вторая производная от бизнеса. Первая производная — это «служба разработки». «Служба эксплуатации» создается чтобы сэкономить на девелоперах — за счет найма более дешевых опсов, которые возьмут на себя часть работы девелоперов по поддерке продукта.
              Даже когда покупается готовое решение — все равно его кто-то разработал и при этом уже произвел подготовку к передаче в эксплуатацию (что включается в цену). Когда разработка ведется в рамках компании — издержки на передачу в эксплуатацию теоретически должны снижаться, но при возникновении разногласий между разработкой и эксплуатацией — они могут даже увеличится. А дальше бизнес смотрит просто — где меньше затраты — когда девелоперы занимают поддержкой или когда девелоперы передают продукт выделенному отделу эксплуатации.

              Вроде бы правильные слова про документирование — на самом деле означают создание дополнительной документации специально для опсов. Вроде как документацию для опсов должны писать опсы, но они не могут, потому что ничего не знают и вешают эту нагрузку на девелоперов. И причина проста — опсы не участвовали в разработке и не разбираются в уже существующей документации и продукте. При этом девелоперы пишут простую и понятную со своей точки зрения документация для опсов, а опсы в ней не могут разобраться и усложняют требования к документированию. А это в свою очередь требует больше времени и в результате увеличивает издержки на передачу в эксплуатацию — потому что девелоперы занимаются не своей основной работой, а писательством на заказ. Ну а дальше — эксперименты направленные на вовлечение в процесс разработки опсов, вплоть до переименовывания их в девопсов.
                0
                Вот именно об этой позиции я и говорил выше в описании подмены понятий. Разработка это не программисты, а «опсы» это не админы. Взгляните на это, как на процессы создания и дальнейшего обслуживания. В обоих процессах будут участвовать как dev, так и ops, практически всегда. Инфраструктуру не dev'ы готовят, баги не админы исправляют.

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

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

                  0
                  К сожалению, сведение все к абстрактным «службам» и взаимодействию между ними приводит к катастрофическим последствиям.

                  Вообще сталкивался с шикарным случаем — большая международная корпорация, процессы прописаны от и до, все регламентировано и прекрасно формализированно. Разработчик написал некий функционал, но бюрократию не осилил, так что запустил свое творение на одном из шаред дев серверов. Все прекрасно работало, данные генерились даже после увольнения разработчика более года. Пока сервером не перестали пользоваться другие разработчики. Сервер погасили и данные перестали генериться — началось расследование что за фигня. Нашли причину, сервер подняли обратно и начали думать что делать дальше. Решили «продуктизировать» функционал в виде отдельного продукта и досталась эта работа мне. И вот этот проект «продуктизации» занял более четырех месяцев! Протащить готовый функционал через все необходимые процессы с написанием и подписанием всех необходимых документов (спека на функционал была написана оригинальным разработчиком, так что все остальные докумены — производные от нее) — более четырех месяцев!!!
                  Там в компании вообще все печально — банально выкатить релиз на стейдж это: написать стейдж деплоймент гайд (часа 2-3 с паралельным деплойментом в дев энвайроменте); разобраться кто должен подписать этот гайд в этот раз (часов примерно 5) и создать ревью; пинать подписантов до победного конца (недели полторы-две); подождать очередного планнига опсов (1-4 дня); подождать самого деплоймента (1-2 дня); понаблюдать за деплойментом (до 1 часа) скрестив пальцы чтобы в этот раз опс осилил копипаст из гайда в терминал без самодеятельности (бывали преценденты с заходом на продакшн хост вместо стейджа, при том, что в гайде даже ссш команды с правильными именами хостов прописаны). Для продакшна — повторить.

                  И когда менеджер по работе с клиентами приходил ко мне с пустяковым запросом — минимальный срок я выставлял в полтора месяца. И пояснял — 20 минут на оформление запроса, 5 минут на изменение в коде, 30 минут на тестирование, две недели на подготовку стейдж деплоймента, две недели на стейдже, две недели на подготовку продакшн деплоймента. Более быстрый процесс — только через аварийный деплоймент с визой руководителя на три уровня выше моего начальника. Оптимизация — невозможна, невовремя созданные ревью документов — закрываются как нарушающие процесс. Подписать ревью быстрее чем за полторы-две недели — только с помощью того самого руководителя на три уровня выше моего начальника, у остальных область накрытия живительного пинка маловата.
                  Причем раньше было хуже — кьюэи были отделены такой же бюрократической стеной как опсы и добавляли от двух до четырех недель на тестирование. Но удалось их втащить в процесс разработки — с автоматической регрессией и добавленим/изменением кейсов сразу по изменению кода.
                    0
                    На самом деле, то о чем Вы говорите, это как раз НЕ налаженный процесс. Я работал в подобных организациях. Обычно такое происходит когда:
                    а) нет единого собственника системы,
                    б) процессы построены ITSM теоретиками, ни разу в жизни не участвовавшими в реальной работе регламентируемого процесса.
                    И вот когда оба фактора объединяются — некие абстрактные «идеальные» процессы начинают считаться священной коровой, человека, который был бы заинтересован в нормальной работе, между эксплуатацией и разработкой просто нет, получается всякая разная фигня. А разруливать её некому.
                    Суть хороших процессов в том, что бы все происходило быстро и предсказуемо, что бы не забывать ничего важного и не изобретать один и тот же велосипед по нескольку раз в день, а не в сборе подписей в листе согласования.
                      0
                      Это реальный процесс, в той форме в которой он самостабилизируется. В той форме которую он приобретает в результате взаимодействия с другими процессами. До единого владельца там толстый-толстый слой линейных менеджеров. В том числе и «прекрасно сертифицированных» специалистов по процессам с «огромным опытом».
                      Проблема в том, что наличие этого процесса как и других никак не коррелирует с достижением цели поставленной бизнесом. А вот количество попыток достижения цели — коррелирует. Каждый релиз — это попытка, которая дает информацию, что же неверного было в начальных предпосылках. В результате — чем больше было сделано релизов, тем ближе фактический результат проекта к ожидаемому. А это как раз критерий оценки проекта с точки зрения бизнеса.
                        0
                        — чем больше было сделано релизов, тем ближе фактический результат проекта к ожидаемому.

                        Или чем качественнее был проработан способ достижения этого результата изначально, т.е. чем ближе к изначальной цели была каждая попытка. Вы говорите про итерационный метод, я — про качество изначальной проработки итерации. Естественно в жизни к хорошему результату приведут только оба пути одновременно, с первого раза всегда на 100% попадать не получится. Каждая неудавшаяся попытка это либо вред, либо недополученная польза, т.е. при итерационном методе всё равно time-to-market большой, просто по тому, что определиться он завершением работы над фичей, а не выводом в продуктив первой попытки. На анализ в любом случае будет потрачено время, только при итерационном методе тратится время еще и на переделки. Я не говорю, что не надо пробовать. Я говорю, что грамотный аналитик способен предсказать результат очень большого количества попыток. А грамотный энтерпрайз архитектор способен построить систему так, и в первую очередь я про бизнес-процесс, что бы по результатам вывода в продуктив первой же версии фичи потребовались лишь незначительные исправления и доработки логики. В большинстве случаев это в итоге получится быстрее и дешевле. В большинстве случаев итерационный метод скатывается к бессистемному тыканию пальцем в небо, так же как в вашем примере Waterfall скатывается к бюрократии.

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

                          0
                          Изначально проработать способ достижения достаточно подробно можно только для тех областей, для которых уже все факторы известны, измерены и их влияние можно учесть. Грубо говоря, когда проектируется здание — проектировщик опирается на наработки кучи НИИ — геологии, материаловедения и т.д. А когда работает аналитик — в ряде случаев он может только предполагать. И подтверждение можно получить только в результате НИОКР (R&D), вот только для разработки софта НИОКР стоит не сильно дешевле обычного процесса разработки. И результат зачастую зависит только от того, как задачу поймет разработчик (да-да, одну и ту же самую задачу можно решить по разному). А расписать задачу до однозначности — требует столько же, а иногда и больше, времени сколько требуется на реализацию разработчику.
                          Собственно вся индустрия стартапов построена на том факте, что гигантские корпорации с многотысячными штатами, многомиллиардными бюджетами, зрелыми процессами, аналитиками, энтерпрайз архитекторами, «отделами разработки» и «отделами эксплуатации» не в состоянии воспроизвести путь маленькой быстро адаптирующейся команды стартапа за разумное время и с приемлемым бюджетом. Просто потому, что маленькая команда может потыкать пальцем в небо очень быстро и в результате таки нащупать там новый рынок или источник дохода.

                          У большой системы в принципе не может быть единого собственника. В том бизнес-юните или департаменте или направлении (ага, тайтлы менялись), в котором работал я — работало еще более сотни одних только разработчиков. О некоторых частях системы я имел весьма теоретическое понятие — просто потому, что там изменения происходили чаще, чем я заглядывал в эту часть системы. Или смотришь — идут данные от чего-то с забубенной аббревиатурой, вроде один продукт, глянул на доки — а там еще одна система состоящая из кучи продуктов с не менее забубенными аббревиатурами. (Продуктом мы называли минимальную развертываемую функциональность, чаще всего один, иногда несколько системных пакетов. По факту один продукт мог разворачиваться на кластере в несколько десятков апп хостов и требовать под себя пару-тройку дб кластеров.) К одному человеку все сводилось уже довольно далеко от разработки. И этот человек, условно, собственник — не бегает за пользователями — у него для этого есть отдел продаж. И куча менеджеров для внутренних коммуникаций.
                          А менеджер по работе с клиентами вообще-то тоже один из непрямых (через несколько слоев линейных менеджеров) подчиненных условного собственника. И ко мне он пришел не напрямую, а получив контакт от моего менеджера. Просто я был одним из знающих свой кусочек системы, берущих на себя ответственность за фичу и умеющих полный цикл — от сбора требований до вывода на продакшн.
                      0
                      ;)
                      яркий пример того, почему devops не про ит, а про бизнес.

                      с точки зрения ИТ, ситуация выше — идеальная. все регламентировано, все зафиксировано, все риски предусмотрены, ответственность на каждом шаге известна, прозрачные связи с сопутствующими процессами (capacity, event, etc mngt).

                      одна только проблема — «недалекий» бизнес хочет быстрее и дешевле.
                        0
                        На самом деле немножко по другому:

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

                        А в IT эта проблема всплывает, так как ошибка из-за незрелого процесса не вносит диких затрат на этапе внедрения. Потому что можно «тяп-ляп и в продакшен» а если чего то DevOps поможет быстренько доставить фикс до заказчика.
                        И вот бизнес сидит и управляет рисками… толи по-быстрому выкатится и начать грести бабло лопатой пока конкуренты не очухались. Толи waterfall-ить по-черному чтобы снизить потери если что-то пойдет не так.
                        И да в эпоху облаков и тонких клиентов это таки работает впрочем не везде и DevOps тут ни разу нипричем.
                        Как пример: компания разрабатывающая прошивки для автомобильных «головных устройств» у которых если что прошивку по воздуху не обновить — и обновление это отзывная компания по всему миру. Там как раз и надо «capacity, event, etc mngt.»

                          0
                          Со всем согласен, кроме
                          DevOps поможет быстренько доставить фикс до заказчика.

                          DevOps не про быструю доставку. DevOps про то, что перед бизнесом за работу одного продукта/сервиса в части ИТ несет ответственность один человек, а если конкретизировать, то за:
                          — если нужна доступность, то за доступность
                          — если нужен TTM, то за TTM
                          — если нужна безопасность, то за безопасность
                          — и т.д.
                          Какие при этом используются инструменты, в общем то все равно. Т.е. у вас может не быть быстрой доставки, потому что бизнесу это не нужно, но вполне может быть взрослый DevOps.
                            0
                            Ну я бы сказал, что даже не перед бизнесом, а перед другими опсами. Вообще я более полутора лет выпрашивал человека от опсов в команду с двумя целями — представлять опсов при разработке каждой фичи в команде и представлять команду при общении с опсами.
                            Далеко не всегда при разработке учитывается точка зрения опсов (ну или то, что разработчик считает точкой зрения опсов). Особенно без напоминания. И внести изменения в написанную, задокументированную и протестированную фичу через пару месяцев после завершения работы над ней — гораздо сложнее чем поменять ее сразу после написания.
                            И команда не всегда готова принять запрос на фичу — что при ватерфолле, что при скраме. При ватерфолле команда открыта к запросам только на этапе до фиксирования скоупа. А в периоды релиза — вообще лучше не трогать. При скраме — только в моменты подготовки к планированию. В беклог то запрос добавят в любой момент, но не факт, что запрос будет понятен, а человек умеющий задавать правильные вопросы — будет свободен.
                              0
                              Ну вот мы с Вами ровно об одном и том же на самом деле. Просто называем это разными словами немного.
                              0
                              Проблема как раз в том, что управления рисками нет. Есть процесс максимально снижающий риски и его начинают применять повсюду. Даже когда он никак не влияет на риски — все равно используют его. И тратить полтора месяца на деплоймент мелкого изменения веб юая доступного только внутренней команде (спонсор проекта имел достаточный вес чтобы запустить процесс релиза с одной единственной фичей) — это весьма неэкономично. Но происходит — потому что опсы предпочитают перестаховаться в связи с незнанием продукта и команды, невозможностью оценить риски из-за своего незнания.
                                0
                                На самом деле не из-за незнания, а из-за нежелания сотрудничать и отсутствие общего руководства, понимающего что происходит и способного настучать по шапке. Того самого собственника системы.

                                P.S. я своими глазами видел не раз, как мелкое изменение внутреннего интерфейса рушит верстку внешнего. Например из-за неожиданно общих библиотек. Но это скорее вопрос уже к тестированию:-)

                    Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.

                    Самое читаемое