
Всем привет. Меня зовут Станислав Большаков, я архитектор. В ИТ‑холдинге Т1 проектирую и развиваю платформу «Т1 Облако»: участвую в разработке новых функций, тестировании и обеспечении надёжности. Сегодня поговорим о том, почему «зелёные» дашборды не всегда означают хороший пользовательский опыт. В прошлом году я выступил на эту тему на конференции Импульс Т1, а сейчас рассказываю здесь.
Надёжность сама по себе — полезное свойство любой ИТ‑системы. Но ещё важнее то, какие решения мы можем принимать, понимая, насколько система надёжна. Главная мысль простая: есть короткий путь от огромного количества технических метрик до понимания того, что на самом деле происходит с пользователем. И начинается этот путь с вопроса, который инженер должен регулярно себе задавать: «Зачем?»
Как устроена облачная платформа
Облачная платформа — это большая распределённая система, которая может охватывать несколько центров обработки данных. В её основе лежит вполне привычное оборудование: серверы, системы хранения данных, коммутаторы, маршрутизаторы, балансировщики нагрузки и другие компоненты физической инфраструктуры.
Но настоящая сложность начинается, когда мы хотим превратить всё это оборудование в сервис самобслуживания. Пользователь должен иметь возможность самостоятельно создавать виртуальные машины, подключать диски, настраивать сети и управлять ресурсами через графический интерфейс или API.
Для пользователя всё выглядит довольно просто: выбрал параметры виртуальной машины, нажал кнопку «Создать» и ждёшь результат. А за этой кнопкой скрывается целая цепочка взаимодействий между различными системами: нужно проверить права доступа и квоты, подобрать вычислительный узел, подготовить загрузочный диск, настроить виртуальную сеть и запустить машину. За каждую из этих операций отвечают свои компоненты: оркестраторы вычислительных ресурсов, блочных устройств и виртуальных сетей, системы управления хранилищами, программно‑определяемая сеть и другие службы платформы. Все они должны работать согласованно, чтобы пользователь получил нужный результат.
При этом каждый компонент может быть исправен сам по себе, но вся цепочка не обязательно завершится успешно. Например, виртуальная машина может застрять на этапе подготовки диска, хотя API отвечает, планировщик работает, а гипервизоры доступны.
Поэтому надёжность облака нельзя свести к доступности отдельных серверов или программных компонентов. Нас интересует не только то, работают ли они, но и то, способна ли платформа предоставить услугу целиком.
Два слоя надёжности
Если немного упростить архитектуру облачной платформы, то можно выделить две основные части: слой управления (Control Plane) и слой данных (Data Plane). Они решают разные задачи, поэтому и оценивать их надёжность нужно по‑разному.
Слой управления отвечает за управление облачными ресурсами: создание виртуальных машин, подключение дисков, настройку сетей и другие операции. Здесь работают API, планировщики, оркестраторы и другие управляющие компоненты.
На первый взгляд, всё просто: есть запросы, ошибки и время выполнения. Для наблюдения за такими системами хорошо подходит методология RED: Rate (интенсивность запросов), Errors (ошибки) и Duration (длительность выполнения).
Но у облачных платформ есть особенность — многие операции выполняются асинхронно. Например, API может успешно принять запрос на создание виртуальной машины, но сама машина так и не появится. Поэтому недостаточно измерять только успешность HTTP‑запросов. Важно понимать, завершилась ли операция, сколько времени она заняла и получил ли пользователь ожидаемый результат.
Слой данных — это часть инфраструктуры, которая непосредственно обслуживает пользовательскую нагрузку. Гипервизоры обеспечивают выполнение виртуальных машин, системы хранения обрабатывают операции ввода‑вывода, а сетевая инфраструктура передаёт пользовательский трафик.
И здесь подход к оценке надёжности уже другой. Виртуальную машину пользователь может создать один раз, а эксплуатировать месяцами. Его гораздо меньше интересует доступность API создания ВМ, чем то, насколько стабильно работает уже запущенная машина.
Причём сам факт доступности ресурса ещё не означает, что услуга предоставляется качественно:
-
Виртуальная машина может работать, но испытывать нехватку процессорного времени.
-
Блочный диск может быть доступен, но задержки операций ввода‑вывода сделают работу приложения практически невозможной.
-
Сетевые интерфейсы могут быть активны, но потери пакетов или недостаточная пропускная способность приведут к деградации пользовательских сервисов.
Для оценки качества услуги нам нужны показатели доступности, задержек и производительности.
Есть и ещё одно важное различие. Отказ слоя управления не обязательно приводит к остановке слоя данных. Например, пользователь может потерять возможность создавать новые виртуальные машины, но уже запущенные продолжат работать. Возможна и обратная ситуация: управление облаком доступно, новые запросы успешно обрабатываются, а часть существующих виртуальных машин испытывает проблемы с производительностью или связностью.
Поэтому говорить об одной общей доступности облачной платформы не совсем правильно. Надёжность управления ресурсами и надёжность их фактической работы — разные характеристики, и измерять их необходимо отдельно.
Почему «зелёные» дашборды обманывают

Когда возникает задача повысить надёжность системы, первая реакция инженеров часто вполне предсказуема: «Нужно больше мониторинга». Мы устанавливаем экспортёры метрик, собираем журналы, настраиваем трассировки, рисуем дашборды и создаём оповещения.
В какой‑то момент у нас появляются тысячи метрик и десятки красивых панелей. Мы знаем практически всё о состоянии серверов, баз данных и отдельных сервисов. Но стали ли мы лучше понимать, насколько хорошо работает облако для пользователя?
Самая неприятная ситуация возникает, когда пользователь говорит: «У нас всё плохо», а инженер открывает мониторинг и видит сплошные зелёные панели. С точки зрения инфраструктуры всё действительно может быть в порядке: процессоры не перегружены, памяти достаточно, базы данных отвечают, серверы не перезагружаются, количество ошибок не превышает установленных порогов. Но пользователь при этом жалуется: «Всё тормозит. Ничего не работает».
И противоречия здесь нет.
Например, пользователь создаёт виртуальную машину и ждёт двадцать минут вместо привычных двух. API успешно принял запрос, все необходимые компоненты доступны, критических ошибок нет. Но где‑то внутри платформы операция слишком долго ожидает выполнения. Каждый компонент по отдельности может укладываться в установленные для него пороги, а суммарное время ожидания оказывается совершенно неприемлемым.
Проблема в том, что мы измеряем состояние отдельных компонентов, тогда как пользователь взаимодействует с системой целиком. И доступность всех компонентов ещё не гарантирует, что они способны совместно предоставить услугу с ожидаемым качеством. Просто пользователь и инженер смотрят на одну и ту же систему с разных сторон. Пользователь описывает свой опыт и ощущения: «долго», «тормозит», «не работает». Инженер оперирует техническими показателями: временем ответа, количеством ошибок, загрузкой компонентов.
И самое интересное, что оба могут быть правы. Наша задача — научиться сопоставлять эти две картины и переводить пользовательские ощущения на язык измеримых характеристик системы.
Это не означает, что привычные технические метрики бесполезны. Они необходимы для диагностики и поиска причин неисправностей. Но прежде чем разбираться, почему система работает плохо, нужно научиться определять, что именно для пользователя означает «плохо». А для этого сначала придётся понять, какие действия пользователя действительно важны. Здесь мы и приходим к понятию критического пользовательского сценария.
Критический путь пользователя
С облачной платформой можно взаимодействовать сотнями разных способов. Создать виртуальную машину, подключить диск, изменить правила межсетевого экрана, получить список ресурсов или посмотреть историю потребления. Но далеко не все эти операции одинаково важны для пользователя и бизнеса.
Здесь нам помогает понятие критического пользовательского сценария (Critical User Journey, CUJ). По сути, это наиболее важные действия пользователя, успешность которых определяет, насколько хорошо система выполняет своё назначение. Причём важность сценария определяется не только тем, как часто его выполняют, но и последствиями отказа.
Возьмём, например, биллинг и работу виртуальных машин. Оба направления критически важны для облачного провайдера, но последствия их недоступности различаются. Если система расчёта стоимости временно перестала обрабатывать события, но данные о потреблении ресурсов надёжно сохраняются, то расчёт можно выполнить позже. Это неприятно, но пользовательская нагрузка продолжит работать. Другое дело, если мы теряем сами данные о потреблении — здесь уже возникает риск финансовых потерь.
А вот если виртуальная машина перестала выполнять пользовательскую нагрузку, то последствия могут наступить немедленно: от недоступности отдельного приложения до остановки важных бизнес‑процессов.
Есть и менее очевидные различия. Например, невозможность создать новую виртуальную машину для одного пользователя может быть небольшой неприятностью, а для другого, у которого инфраструктура автоматически масштабируется под нагрузкой, — причиной серьёзного сбоя. Поэтому универсального списка критических сценариев не существует. Мы должны понимать, кто пользуется нашей системой, какие задачи решает и во что ему обходятся ошибки и задержки.
И ещё один важный момент: критический сценарий не заканчивается там, где заканчивается API‑запрос. Если пользователь заказал виртуальную машину, то нас интересует не только успешное принятие запроса, но и получение работающего ресурса за приемлемое время.
Определив такие сценарии, мы можем перестать измерять всё подряд с одинаковым приоритетом и сосредоточиться на том, что действительно влияет на качество услуги.
Как превратить ощущения в числа

Допустим, мы определили, какие пользовательские сценарии действительно важны. Теперь нужно понять, как измерить качество их выполнения.
Возьмём уже знакомый пример с созданием виртуальной машины. Пользователь ожидает, что через несколько минут после отправки запроса получит работающий ресурс. Если машина создаётся за две минуты — всё хорошо. Если за двадцать — операция может завершиться формально успешно, но вряд ли пользователь останется доволен.
Поэтому недостаточно просто считать успешные и неуспешные запросы. Нам нужно определить, какой результат мы считаем хорошим с точки зрения пользователя. Здесь можно условно разделить длительность выполнения операций на две категории:
-
Хорошая: операция выполняется достаточно быстро, чтобы не раздражать пользователя и не нарушать ожидания взаимодействующих систем. Например, запрос к API завершается за приемлемое время и не приводит к таймауту.
-
Плохая: операция выполняется слишком долго или завершается таймаутом. Она может ещё продолжаться и даже успешно завершиться, но пользователь к этому моменту уже ушёл к другому облачному провайдеру.
Например, можно договориться, что хорошим созданием виртуальной машины считается операция, которая успешно завершилась за пять минут. Всё, что заняло больше времени, даже если машина в итоге появилась, уже не соответствует нашим ожиданиям. Пять минут здесь лишь пример, а не универсальный норматив.
Теперь мы можем посчитать долю хороших операций среди всех учитываемых попыток создания ВМ. Причём время измеряем от момента отправки запроса до фактического завершения операции, а не до ответа API. Правила учёта некорректных запросов и отменённых операций при этом нужно определить отдельно.
Но не все сценарии удобно оценивать по отдельным операциям. Для уже работающей виртуальной машины важнее её доступность на протяжении времени. Для диска — задержки операций ввода‑вывода, для сети — потери пакетов и задержки передачи данных. Таким образом, для одних сценариев мы оцениваем успешность событий, для других — качество работы ресурса во времени. Главное, что теперь вместо субъективного «работает медленно» у нас появляется измеримый показатель. Мы можем сравнивать его с ожиданиями пользователя, наблюдать за изменениями и понимать, действительно ли наши инженерные решения делают систему лучше.
Цели надёжности и «достаточно хорошо»
Мы научились измерять качество услуги с точки зрения пользователя. Теперь возникает следующий вопрос: «А насколько надёжной должна быть наша система?»
Если спросить бизнес, какую доступность он хочет получить, то ответ, скорее всего, будет предсказуемым: 100%. И уже вчера. Но стремление к абсолютной надёжности может оказаться неоправданно дорогим. Можно резервировать оборудование, строить географически распределённые системы, устранять единые точки отказа и автоматизировать восстановление. Однако каждая дополнительная «девятка» в показателе доступности обычно обходится всё дороже. Есть отрасли, где это действительно критично: атомная энергетика, космические системы, системы жизнеобеспечения и медицинская инфраструктура. Такие системы многократно дублируют и тщательно тестируют, и они дорого обходятся в эксплуатации и развёртывании.
И здесь есть интересный парадокс: чем больше механизмов обеспечения отказоустойчивости мы добавляем, тем сложнее становится сама система. А сложность, как известно, тоже умеет ломаться.
Например, можно построить прекрасную отказоустойчивую инфраструктуру в трёх центрах обработки данных, а затем одной ошибкой в конфигурации одновременно вывести из строя все три. Резервирование отлично защищает от отказа оборудования, но далеко не всегда спасает от человеческой изобретательности.
Поэтому в инженерной практике есть очень полезное слово — «достаточно». Не идеально, не максимально хорошо и уж точно не плохо. Достаточно надёжно для тех задач, которые решает система.
Для одного сервиса несколько минут недоступности могут остаться практически незамеченными. Для другого даже короткий сбой приведёт к серьёзным финансовым потерям. И требовать от обоих одинакового уровня надёжности просто не имеет смысла.
При этом повышение надёжности всегда имеет свою цену. Это не только оборудование и резервные мощности, но и время команд, которое можно потратить либо на устранение потенциальных отказов, либо на развитие новых возможностей продукта.
И вот здесь начинается интересный диалог. Бизнес хочет новые функции, пользователи — стабильную работу, а инженеры иногда мечтают хотя бы неделю ничего не трогать. Нам нужен способ договориться о разумном уровне надёжности и понять, когда стоит заниматься стабилизацией, а когда можно спокойно развивать систему. Причём желательно не на уровне «мне кажется, всё нормально», а опираясь на измеримые показатели. Именно для этого существуют SLI, SLO и бюджет ошибок, о которых поговорим дальше.
Уровень обслуживания и бюджет ошибок
Итак, мы определили, какие пользовательские сценарии важны, научились измерять качество их выполнения и договорились, что абсолютная надёжность нам не нужна. Осталось понять, как всё это использовать на практике.
Для этого в инженерии применяют два понятия: SLI (Service Level Indicator) и SLO (Service Level Objective). Особенно широкое распространение они получили благодаря подходу Site Reliability Engineering (SRE).
SLI — измеримый показатель качества услуги. Например, доля виртуальных машин, успешно созданных за пять минут, или доля времени, в течение которого виртуальная сеть обеспечивает необходимую связность.
SLO — целевое значение этого показателя за определённый период. Проще говоря, SLI показывает, как система работает на самом деле, а SLO — насколько хорошо мы договорились работать.
Допустим, мы установили SLO для создания виртуальных машин на уровне 99,9% за 30 дней. Это означает, что не менее 99,9% учитываемых попыток создания ВМ должны завершиться успешно и уложиться в пять минут.
А что с оставшимися 0,1%? Это наш бюджет ошибок (Error Budget). Если за расчётный период пользователи 10 тысяч раз попытались создать виртуальные машины, мы можем допустить десять операций, которые завершились ошибкой или не уложились в пять минут. Одиннадцатая такая операция при том же общем количестве попыток означает, что по итогам периода мы не достигли установленного SLO.
Конечно, бюджет ошибок — это не разрешение специально ломать систему. Это способ признать, что отказы неизбежны, и договориться об их допустимом уровне.
Самое интересное начинается, когда мы используем этот бюджет для принятия решений. Если ошибки происходят редко и бюджет расходуется медленно, то у нас остаётся пространство для изменений, экспериментов и развития платформы. Если же бюджет стремительно заканчивается, то это повод разобраться в происходящем и, возможно, отложить рискованные изменения в пользу стабилизации.
Причём совсем не обязательно ждать, пока бюджет закончится. Если мы потратили половину месячного бюджета за один час, формально SLO ещё может выполняться, но очевидно, что что‑то пошло не так. Поэтому важно следить не только за остатком бюджета, но и за скоростью его расходования.
Разумеется, решение об ограничении изменений нельзя принимать автоматически по одному числу. Для этого нужна заранее согласованная политика: при каких условиях мы приостанавливаем выпуск новых функций, когда сосредоточиваемся на устранении неисправностей и какие изменения допустимы даже при исчерпанном бюджете.
И ещё один нюанс: SLO не обязан быть одинаковым для всех услуг и операций. Могут быть установлены разные цели для создания виртуальных машин и доступности уже работающих ресурсов и операций с блочными дисками. Одни показатели удобно рассчитывать по количеству операций, другие — по времени.
В результате бюджет ошибок становится не просто числом в отчёте, а инструментом, который помогает ответить на вполне практический вопрос: «Можем ли мы сейчас позволить себе новые изменения, или сначала стоит разобраться с надёжностью того, что уже работает?»
И что особенно приятно — обсуждать это можно не на уровне «кажется, у нас всё плохо», а с конкретными числами на руках.
Что делать с остальными метриками?
После появления SLI и SLO может возникнуть закономерный вопрос: «А что теперь делать с тысячами технических метрик, которые мы так старательно собирали? Неужели всё зря?» Конечно, нет. Просто теперь у каждой метрики появляется своё место.
Пользовательские SLI помогают понять, что услуга перестала соответствовать нашим ожиданиям, а технические метрики — разобраться, почему это произошло.
Представим, что пользователи начали жаловаться на производительность блочного хранилища. Диски подключены, доступны, операции ввода‑вывода выполняются, но приложения работают заметно медленнее обычного. Особенно недовольны владельцы баз данных, у которых внезапно выросло время выполнения транзакций.
Допустим, мы измеряем задержки операций ввода‑вывода со стороны потребителя услуги при определённом профиле нагрузки. И видим, что всё больше операций перестают укладываться в допустимое время. Качество услуги действительно ухудшилось. Но почему?
И вот здесь начинается настоящая инженерная работа. Мы проверяем задержки на разных участках пути ввода‑вывода, глубину очередей, загрузку систем хранения, состояние сети хранения и действующие ограничения производительности. Возможно, возникла конкуренция за ресурсы, перегружен один из компонентов или неправильно настроены ограничения IOPS.
Причём средние показатели могут оставаться вполне приличными. Например, 99 операций из 100 выполняются за несколько миллисекунд, а одна занимает сотни миллисекунд. Для базы данных, которая ожидает завершения записи перед подтверждением транзакции, такие задержки могут оказаться весьма болезненными.
Без технических метрик мы бы знали, что пользователи испытывают проблемы, но поиск причины превратился бы в увлекательную игру «угадай, где тормозит». Получается довольно простая схема: SLI помогает оценить качество услуги, а технический мониторинг — найти причину его ухудшения.
Но есть важный нюанс. Не стоит ждать, пока пользовательские показатели начнут ухудшаться. Если мы замечаем, что при сопоставимой нагрузке увеличиваются задержки, накапливаются очереди или система приближается к пределам своей производительности, то лучше разобраться с этим заранее.
В идеале, нам нужны обе картины: качество услуги с точки зрения пользователя и техническое состояние компонентов, которые эту услугу обеспечивают. Первая помогает оценить влияние проблемы, вторая — найти её причину или предотвратить деградацию.
Иными словами, мониторинга меньше не стало. Зато появилось понимание, зачем мы всё это измеряем.
От реактивного управления к проактивному
Итак, мы определили критический путь пользователя, затем выбрали наиболее важные операции, перевели пользовательские ожидания в технические индикаторы и установили для них реалистичные значения. После этого рассчитали бюджет ошибок и используем его для баланса между разработкой и стабилизацией. При этом мы сохранили технические метрики, журналы и трассировки для поиска причин проблем.
Главный результат — мы перестали обсуждать надёжность на языке ощущений. Вместо «мне кажется, система стала менее стабильной» можно сказать: «Снизился SLO управления блочными томами, из-за этого страдают платформенные сервисы и конечные пользователи. Нужно стабилизировать ситуацию», или «Все SLO выполняются, бюджет ошибок не расходуется. Мы можем безопасно провести эксперимент и взять в работу задачи из бэклога развития». Так решения становятся предметными, проверяемыми и основанными на данных.
В этом году в шестой раз пройдёт конференция Импульс Т1. На ней вас ждут интересные прикладные доклады, мастер-классы и эксперименты в лабораториях.
Источник: habr.com