<?xml version="1.0" encoding="utf-8" ?><rss version="2.0" xmlns:tt="http://teletype.in/" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:media="http://search.yahoo.com/mrss/"><channel><title>Просто DevOps</title><generator>teletype.in</generator><description><![CDATA[Девопсим, девопсим, девопсим!
]]></description><image><url>https://img3.teletype.in/files/ea/54/ea54cbd2-832c-4de6-9763-0f31d29f5122.png</url><title>Просто DevOps</title><link>https://teletype.in/@prosto_devops</link></image><link>https://teletype.in/@prosto_devops?utm_source=teletype&amp;utm_medium=feed_rss&amp;utm_campaign=prosto_devops</link><atom:link rel="self" type="application/rss+xml" href="https://teletype.in/rss/prosto_devops?offset=0"></atom:link><atom:link rel="next" type="application/rss+xml" href="https://teletype.in/rss/prosto_devops?offset=10"></atom:link><atom:link rel="search" type="application/opensearchdescription+xml" title="Teletype" href="https://teletype.in/opensearch.xml"></atom:link><pubDate>Thu, 19 Nov 2026 08:31:58 GMT</pubDate><lastBuildDate>Thu, 19 Nov 2026 08:31:58 GMT</lastBuildDate><item><guid isPermaLink="true">https://teletype.in/@prosto_devops/p969ryoy9Ty</guid><link>https://teletype.in/@prosto_devops/p969ryoy9Ty?utm_source=teletype&amp;utm_medium=feed_rss&amp;utm_campaign=prosto_devops</link><comments>https://teletype.in/@prosto_devops/p969ryoy9Ty?utm_source=teletype&amp;utm_medium=feed_rss&amp;utm_campaign=prosto_devops#comments</comments><dc:creator>prosto_devops</dc:creator><title>ЧЕ НАДО ЗНАТЬ?</title><pubDate>Wed, 22 Oct 2025 23:25:56 GMT</pubDate><category>devops</category><description><![CDATA[<img src="https://img2.teletype.in/files/df/c2/dfc280a3-95cc-4081-a5ec-f0bbce800219.png"></img>Как выучить столько всего, и надо ли вообще так много учить? А что надо уметь? А как практиковаться? А сложно ли, а, а, а...]]></description><content:encoded><![CDATA[
  <h2 id="DMT0">Что учить, чтобы стать девопсом?</h2>
  <p id="U07w">Как выучить столько всего, и надо ли вообще так много учить? А что надо уметь? А как практиковаться? А сложно ли, а, а, а...</p>
  <p id="Lx6V">Эти вопросы звучат регулярно и порождают споры из раза в раз. В этой статье мы разложим всё по полочкам.</p>
  <p id="UQ6e"><strong>Давайте избавимся от лишних вопросов и оставим всего два:</strong></p>
  <ul id="vuYK">
    <li id="Deig">Какая должна быть теоретическая база?</li>
    <li id="7877">Что надо уметь на практике?</li>
  </ul>
  <p id="GV3k"><strong>На них мы и будем отвечать.</strong></p>
  <p id="Xk9J"><strong><em>Из чего состоит любой путь устройства на работу?</em></strong> Понравилось → пошел учиться → пошел на собесы → работаешь → карьерный рост.</p>
  <p id="HaP2">Но при этом всё обучение всегда направлено <strong>на практические задачи</strong>, по сути <strong>на работу</strong>, но <strong>никак не на собеседования</strong>, хотя <strong>именно они - самая важная часть этого пути.</strong></p>
  <p id="EA1K">При этом, работать и проходить собеседования - это совершенно разные вещи, и мы об этом неоднократно говорили. И поэтому вопросы, которые мы оставили ранее, <strong>эволюционируют в такие:</strong></p>
  <ul id="3Mxd">
    <li id="S5Ra">Какая должна быть теоретическая база, чтобы <strong>пройти собеседование?</strong></li>
    <li id="tRf8">Что надо уметь на практике, чтобы <strong>пройти собеседование?</strong></li>
    <li id="hEMq">Какая должна быть теоретическая база, <strong>чтобы работать?</strong></li>
    <li id="PE1D">Что надо уметь на практике, <strong>чтобы работать?</strong></li>
  </ul>
  <h1 id="fvmF">Начинает вырисовываться картина.</h1>
  <p id="0G1N"><strong>Добавляем деталей:</strong></p>
  <p id="jjOf">Конкретные требования по навыкам и знаниям отличаются от одной вакансии к другой.</p>
  <p id="Yeix">Зависит это непосредственно от того проекта, которым предстоит заниматься: масштаб, критичность, размер самой компании, специфика конкретного направления компании. А ещё ваше место в этой структуре — вы сопровождаете и развиваете продукт? или обслуживаете команды, которые занимаются продуктами? или предоставляете инфраструктуру как сервис клиентам? — Уже из этого складывается технологический стек и специфика задач.</p>
  <p id="hhgo">А вот на собеседованиях всё более-менее похоже. Да, понятно, что будет уклон в специфику вакансии: где-то больше докера, где-то надо администрировать облака, кому-то нужен человек для настройки CI/CD. Тем не менее, технические вопросы везде из одного пула: сети, Linux и Kubernetes — основа и будет всегда, а остальное — может будет, может нет. Что остальное? — Об этом чуть позже.</p>
  <p id="AA2Y">Сейчас рассмотрим двух девопсов из бигтеха, у каждого определена своя зона ответственности, у них <strong>одинаковая зарплата и грейд:</strong></p>
  <ul id="Iskq">
    <li id="xbbO">Первый — занимается посторением CI/CD, его задача — чтобы процесс проходил стабильно, пайплайны отрабатывали, джобы выполнялись, код доставлялся.</li>
    <li id="xSZX">Второй — работает <strong>в инфраструктурной команде</strong>, которая разворачивает кубер-кластера другим командам в компании.</li>
  </ul>
  <p id="oYPb">Оба — девопсы, оба — в одной и той же компании, но их зоны ответственности отличаются примено так:</p>
  <figure id="0f45" class="m_retina">
    <img src="https://img2.teletype.in/files/df/c2/dfc280a3-95cc-4081-a5ec-f0bbce800219.png" width="6223" />
  </figure>
  <p id="tN6p">Надо ли учить всё, чтобы пройти и туда, и туда? — нет, потому что это очень долго и неэффективно</p>
  <p id="TRZ0">Или стоит выбрать конкретную специфику и целиться в неё? — нет.</p>
  <p id="bulc">Как ты поёмешь заранее, что именно это направление — твоё? И зачем самому себе уменьшать воронку вакансий? Что надо учить, что важно, а что можно подтянуть по ходу?</p>
  <p id="L2l3">Сначала поговорим о собесах, потому что <strong>именно там решается, будете вы работать или нет.</strong></p>
  <h3 id="1Tz5">Для собеседований надо знать обязательно:</h3>
  <ul id="nGB3">
    <li id="YjKV">Linux</li>
    <li id="hmo6">Сети</li>
    <li id="iGEF">Docker</li>
    <li id="oBkt">Kubernetes</li>
    <li id="XOOM">Ansible</li>
    <li id="Pepl">CI/CD (лучше Gitlab CI)</li>
    <li id="TZyh">Git</li>
  </ul>
  <h3 id="Mv5g">Дополнительно:</h3>
  <ul id="xeLp">
    <li id="lZrA">Terraform</li>
    <li id="SeJp">Облака</li>
    <li id="aHAA">Мониторинг</li>
  </ul>
  <h3 id="Ldnb">Ещё более дополнительно, но может быть полезно:</h3>
  <ul id="ihBJ">
    <li id="FCTX">Брокеры сообщений (Kafka, Rabbit MQ)</li>
    <li id="OwuR">Базы данных (На самом деле PostgreSQL будет достаточно)</li>
    <li id="0792">Код (ЯПы не обязательны от слова совсем)</li>
  </ul>
  <h1 id="bNCD">Теперь подробно БАЗОВЫЙ МИНИМУМ по каждому из инструментов.</h1>
  <p id="fquF">Практической части тоже коснёмся.</p>
  <p id="rO1u"><strong>Вот самый простой гайд, </strong>как понять, что вы знаете на достаточном уровне каждый подпункт в темах ниже?</p>
  <p id="7Nsk"><strong>Если вы можете рассказать:</strong></p>
  <ul id="L5EF">
    <li id="6929">Что это?</li>
    <li id="tNgy">Из чего состоит (сущности)?</li>
    <li id="A37W">Как устроено?</li>
    <li id="TBgU">Где применяется?</li>
    <li id="64Hl">Что мы можем как пользователь/админ с этим делать?</li>
  </ul>
  <p id="Iylo"><strong>То это достаточный уровень.</strong></p>
  <h3 id="zJ1C">Linux — самая обширная тема</h3>
  <p id="x6E2">Спросить могут буквально что угодно. Но вот это спросят точно:</p>
  <ul id="BWmc">
    <li id="Vd4x">инициализация, init, systemd</li>
    <li id="aD4R">процессы</li>
    <li id="MFLr">файловые системы</li>
    <li id="86kE">сети</li>
    <li id="GzLw">память</li>
    <li id="ugUX">права и пользователи</li>
    <li id="gvhi">мониторинг</li>
    <li id="ltBa">траблшутинг</li>
  </ul>
  <p id="qM72"><strong>На практике надо уметь:</strong></p>
  <p id="JsD3">На самом деле 95% рабочих задач, связанных с Linux — это установить нужные пакеты, настроить сеть (как раз порты и файрволл), добавить пользователя, запустить и настроить какой-то сервис (возможно написать под него systemd unit). Ну и траблшутинг, куда же без него — смотрим логи, читаем конфиги, пользуемся утилитами мониторинга, диагностируем проблему.</p>
  <h3 id="hkPH">Сети</h3>
  <p id="pbPz">По сетям в целом можно ограничиться теорией. В целом она и нужна, чтобы в дальнейшем понимать, что вообще происходит. Тут у нас обязательно идут протоколы: IP, TCP, UDP, HTTP/HTTPS, обязательно HTTP статус коды, SSH, TLS/SSL, DNS. Надо понимать, как они работают.</p>
  <h3 id="SB58">Docker</h3>
  <p id="IQTq">Очень популярный, при этом очень простой.</p>
  <p id="coJO">Требуется знать, как он устроен, как писать докерфайлы (из этого кстати состоит 90% задач, связанных с докером у девопса). Знать, как устроены registry — то есть хранища образов. Ну и отличать эти самые образы от контейнеров.</p>
  <p id="0B96">Плюс Kubernetes оркеструет именно контейнеры, так что надо уметь с ними работать.</p>
  <h3 id="Cfp1">Kubernetes</h3>
  <p id="mr2a">А вот как раз и великий оркестратор.</p>
  <p id="sQnh">На собеседованиях — вторая по популярности тема после Linux, спрашивают много, глубоко, постоянно.</p>
  <p id="tmP7">Надо знать архитектуру, компоненты, сущности (pod, deployment, statefulset и так далее), очень важно — сеть в Kubernetes, как он ей управляет и какие для этого есть абстракции.</p>
  <p id="ehHy">Kubernetes наиболее сложная тема и тут, без практики и хорошей подготовки никуда. Чтобы локально попрактиковаться — можно развернуть локально minikube, но более интересный вариант — это развернуть k3d — Kubernetes в Docker-контейнерах. Так получите больше возможностей, и всё-таки это будет по сути полноценный кубер, в отличие от миникуба. Но даже так он требует много ресурсов, по-хорошему хотя бы 8 CPU + 16 RAM чисто под него отдать.</p>
  <h3 id="4XPq">Ansible</h3>
  <p id="5azp">На собеседованиях либо ничего не спрашивают, либо 1-2 вопроса. В основном идут по основным вещам: плейбук, роль и её структура, как выполнить плейбук на 1000 серверов. Грубо говоря, это всё.</p>
  <p id="44BX">Когда дойдет до практики — плейбук можно научиться писать часа за 2.</p>
  <h3 id="eGbb">CI/CD</h3>
  <p id="nrJE">Тут ситуация неоднозначная. Инструменты CI/CD на собеседованиях не вспоминают, но могут задавать вопросы по самой концепции — что такое CI/CD процесс, пример идеального пайплайна и всё в таком роде.</p>
  <p id="cQyC">А вот на практике именно с этим процессом на работе сталкиваешься каждый день:</p>
  <ul id="UENq">
    <li id="wIwn">Надо запустить ansible плейбук — он запускается на CI/CD-агенте, при этом для CI/CD агента написан пайплайн, где сказано, как именно и с какими параметрами запускать плейбук.</li>
    <li id="JtPj">Надо задеплоить новый сервис в Kubernetes — пишем новый пайплайн и конфиги.</li>
    <li id="CN1z">Надо выполнить обновление — нажимаем кнопку, смотрим, как выполнятся пайплайн, если падает — копаем логи, ищем причины, фиксим — и по новой.</li>
  </ul>
  <p id="9VYf">База — сама методология, какие бывают флоу разработки.</p>
  <p id="GePM">Плюс выучить любой CI/CD инструмент и тут на самом деле проще всего начать с GitLab CI, потому что пайплайны в нём — это обычные YAML-файлы, ничего дополнительно настраивать не надо, он работает в единой экосистеме. А попрактиковаться тоже не сложно — можно развернуть его локально и экспериментировать сколько влезет.</p>
  <p id="ooU4">Пользоваться публичным GitLab CI из РФ сейчас не получится из-за санкций. Только Self-hosted.</p>
  <p id="Ny4R">Но зато, в силу своей простоты, GitLab CI даст возможность быстро разобраться, что такое пайплайны, джобы, что можно делать в пайплайнах.</p>
  <p id="TtHN">А дальше освоить любой другой CI/CD инструмент будет очень легко, потому что принципы везде одни.</p>
  <h2 id="xSyl">Дополнительно:</h2>
  <h3 id="AHol">Мониторинг</h3>
  <p id="8QDQ">Самая популярная связка — Prometheus + Grafana. Надо понимать откуда берутся метрики, что надо мониторить (хотя бы золотые метрики гугла), понимать как устроен прометеус: как он забирает метрики, куда складывает, как графана потом их визуализирует.</p>
  <h3 id="nSNu">Terraform</h3>
  <p id="SLwc">Это, пожалуй, самое интересное.</p>
  <p id="DZA5">Специфика РФ такова, что Terraform практически не требуется DevOps-инженерам, особенно в крупных компаниях.</p>
  <p id="I9D2">Поэтому можно не фокусироваться на нём, а если придётся что-то делать на работе — разобраться по ходу дела. Опять же всегда можно спросить у местного сеньора-помидора совет.</p>
  <h3 id="QI4I">Облака, брокеры сообщений, базы данных, код.</h3>
  <p id="xDwB">Облака — не важно.</p>
  <p id="HYCw">Код — не важно.</p>
  <p id="Qbxe">Брокеры и базы — встречается на собесах, всем интересна репликация и юэкапирование, в принципе этого достаточно.</p>
  <hr />
  <p id="0uyS">Этого точно хватит, чтобы <strong>пройти собеседование</strong> и устроиться на работу.</p>
  <h1 id="fYra">Какие вообще бывают вакансии?</h1>
  <figure id="dEIC" class="m_retina">
    <img src="https://img4.teletype.in/files/ff/77/ff77387a-e200-4312-b560-e8c9ee9a5092.png" width="2507.5" />
  </figure>
  <figure id="LvOs" class="m_retina">
    <img src="https://img2.teletype.in/files/d7/b6/d7b68cf1-8b38-479a-9642-4c2a8949905d.png" width="1534.5" />
  </figure>
  <p id="v59M">Вот три рандомных примера на DevOps-инженера, junior-middle-senior — а по требованиям везде одно и то же. Грань между грейдами размыта очень сильно. По сути будет отличаться только ответсвенность и понятность задач. Джуну будут давать хорошо декомпозированные задачи, а мидлам и сеньорам придётся разбираться самостоятельно.</p>
  <p id="5til">Если представить это дело на графиках, то получим примерно такую картину:</p>
  <figure id="ZImB" class="m_column">
    <img src="https://img2.teletype.in/files/df/6a/df6a4143-0299-4dd6-86b8-4dd7c1aff16b.png" width="5211" />
  </figure>
  <figure id="OkY1" class="m_column">
    <img src="https://img1.teletype.in/files/8d/2c/8d2cbdf4-58e3-4833-aec1-5391c62bb867.png" width="5373" />
  </figure>
  <p id="YTuN">Получаем, что на собесах в любом случае будут требовать много, на работе при этом джуну будет проще, у сеньора спросят его основную специализацию, но будут ожидать, что и другие задачи он сможет выполнять.</p>
  <p id="c29P">А мидлы от джунов у нас не отличаются ни задачами, ни собесами. А вот разница в деньгах может быть 1.5-2 раза.</p>
  <p id="jbgj">Какие выводы можем сделать?</p>
  <p id="BEAW">Учите инструменты по гайдлайну выше и спокойно проходите собеседования на миддлов, а потом спокойно работаете.</p>
  <h1 id="dEH2">А когда вы устроитесь - у вас будет свой понятный пул задач и инструментов.</h1>
  <p id="Pksd">Не надо будет распылятся на всё подряд, можно стать экспертом именно в своей области.</p>
  <h1 id="q0ye">А как на собеседование-то попасть?</h1>
  <p id="Nf6E">Ну че, требуется всего-то:</p>
  <ul id="NjIq">
    <li id="tkiv">опыт или портфолио</li>
    <li id="alv4">хорошее резюме</li>
    <li id="SBGL">удача</li>
  </ul>
  <p id="TpLC">Согласитесь — изи.</p>
  <p id="qr5z">И это не шутка — не надо себе усложнять жизнь. Погнали по пунктам:</p>
  <p id="32bF"><strong>Портфолио.</strong></p>
  <p id="6QrU">Во-первых — портфолио совершенно бесполезно. Что делать для портфолио — <strong>не ясно</strong>, кому это будет интересно — <strong>тем более</strong>. <strong>Единственный смысл</strong> портфолио — <strong>попрактиковаться</strong>, чтобы быть увереннее в знаниях, но уж точно не для того, чтобы кому-то показывать. В ДЕВОПСЕ ПРОСТО НЕТ ТАКОЙ ПРАКТИКИ — НИКОМУ НЕТ ДЕЛА ДО ВАШЕГО ПОРТФОЛИО.</p>
  <p id="KmBv"><strong>Опыт.</strong></p>
  <p id="Hka2">Тут интереснее, по сути у вас три пути: стажировка, перекат из другого айти направления или в сразу в джуны/мидлы без опыта.</p>
  <p id="tR42">Если стажировка — всё просто: учим базу — проходим отбор (тестирование, тестовое задание, иногда мини-собес) — вуаля. Отбор сложный, обычно проводят много этапов, но всё абсолютно реально, если захотеть. Знаем много живых примеров. Иногда на стажировках пишут типа <em>“желательно иметь опыт администрирования чего-то или вроде того”</em>, ну..<strong> желательно ≠ надо</strong>, плюс можно,<strong><em> не поверит</em>е</strong>, сказать,<strong> что опыт есть.</strong></p>
  <p id="172G">Перекат из другого направления — самый популярный способ попадания в девопс. Изучаете девопс инструменты, практикуетесь, пишете в резюме всё, что знаете и умеете по девопсу (пусть даже именно на своей работе этого не делали) — идёте откликаться, результат не заставить себя долго ждать.</p>
  <p id="8tPS">Напрямую даже в джуны <strong>без опыта в резюме</strong> — нереально. Поэтому <strong>либо крутить,</strong> <strong>либо идём хоть куда в ИТ</strong>, куда можем, а оттуда переходим через полгодика+-. Крутить можно, но делать надо грамотно — если нет знакомых или кого-то, кто может помочь с этим — найдите, потому что без понимания че вообще реально твориться в айтихе — накрутить нормально не получится, спалят.</p>
  <p id="aTdb">Выбор зависит от разных факторов: время, деньги, цели, обязательства, но точно ясно, что любой выбор — правильный.</p>
  <p id="p83b"><strong>Резюме.</strong></p>
  <p id="RCBQ">Ну да, резюме — это важно, как будто у кого-то были сомнения. На эту тему есть много исследований и различных материалов. Если кратко, то вам нужно:</p>
  <ul id="appK">
    <li id="LqCT">нормально назвать позицию поиска (Devops-инженер)</li>
    <li id="vCSc">нормально назвать должности в опыте (Devops-инженер)</li>
    <li id="cXms">проходить по фильтрам лет опыта (год-два-три и тд)</li>
    <li id="tJkc">иметь нужные ключевые слова в описании (docker лучше, чем докер)</li>
    <li id="KyjL">читаемо описать задачи (понятно и коротко)</li>
    <li id="PVOo">поле <em>“о себе”</em> ничего не решает, но если уж заполняете его то проявите креатив — напишите что-то не банальное.</li>
  </ul>
  <p id="884i"><strong>Удача.</strong></p>
  <p id="CZQn">Охренеть, удача отдельным пунктом реально. На самом деле удачи нет, бывает что получается, но непонятно как — кажется, что просто повезло, но на самом деле просто попали в нужные триггеры. Когда знаешь триггеры заранее — никакой удачи не нужно. Что это за триггеры? Оставайтесь с нами и узнаете.</p>
  <h1 id="oOc9">Ох, ещё ж HR-скрининг.</h1>
  <p id="dOeB"><strong>Сейчас будет самый короткий гайд по HR-скринингу.</strong></p>
  <p id="Kajq"><strong>Во-первых:</strong> HR <strong>ничего не понимает</strong>, кого она ищет и зачем. Она должна понять, что вы <strong>умеете формулировать мысли и передавать их с помощью слов.</strong></p>
  <p id="a1T1"><strong>Во-вторых: </strong>если спросят про опыт, то можно рассказывать супер-поверхностно общими словами, а грузить уже лида на собесе.</p>
  <p id="jiLt"><strong>В-третьих:</strong> на <em>soft-skills</em> вопросы типа:<em> “что вам главное в работе?”, “как относитесь к такой-то ситуации?”</em> <strong>отвечайте так</strong>, как будто вы — <strong>идеальный работник, трудяга, которого хлебом не корми — дай поработать</strong>, дай инициативу проявить и все дедлайны выдержать, жопу порвать, но выдержать.</p>
  <p id="eKps"><strong>В-четвертых: </strong>могут задать простые технические вопросы — имейте в виду.</p>
  <p id="M8F2"><strong>В пятых: </strong>определите для себя требования, по которым отбирать компанию, например, <strong>формат работы</strong>: офис/гибрид/удаленка, <strong>дежурства</strong> — ок/не ок, и т.д. И <strong>по всем</strong> этим <strong>требованиям </strong>— <strong>задайте вопрос</strong> HR, сразу отсекайте те вакансии, которые вам не подходят — <strong>не тратьте время впустую.</strong></p>
  <p id="sXfp">Поздравляем, вы можете пройти 100 скринингов из 100.</p>
  <h1 id="Kb0b">Итог:</h1>
  <p id="qxoh">Что надо знать в конкретно вашем случае — хз. Всё зависит от выбранного пути, обстоятельств и целей.</p>
  <p id="26e3">Вот этот фундамент нужен для всего: Linux, сети, Docker.</p>
  <p id="qCeR">Вот это открывает много дверей: Kubernetes, CI/CD.</p>
  <p id="MaXC">Тоже важно, но не так критично: Ansible, Базы данных, Брокеры сообщений.</p>
  <p id="NDEc">Совсем не критично: мониторинг, облака и terraform.</p>
  <p id="yu21">Порядок базово тоже понятен — ровно тот же, как у самих слов выше. Остаётся только ответить на два вопроса:</p>
  <ul id="KKsr">
    <li id="tmGW">А надо ли тебе вообще в девопс?</li>
  </ul>
  <p id="GeOe"><strong>Если надо</strong> — у нас же уже есть <strong>роадмап</strong> по входу в девпос по стажировкам, есть курсы по всем основным технологиям, а скоро добавятся новые роадмапы.</p>

]]></content:encoded></item><item><guid isPermaLink="true">https://teletype.in/@prosto_devops/v2QDwYkGcyU</guid><link>https://teletype.in/@prosto_devops/v2QDwYkGcyU?utm_source=teletype&amp;utm_medium=feed_rss&amp;utm_campaign=prosto_devops</link><comments>https://teletype.in/@prosto_devops/v2QDwYkGcyU?utm_source=teletype&amp;utm_medium=feed_rss&amp;utm_campaign=prosto_devops#comments</comments><dc:creator>prosto_devops</dc:creator><title>ОТКАТ ИЗМЕНЕНИЙ</title><pubDate>Thu, 17 Jul 2025 01:06:17 GMT</pubDate><media:content medium="image" url="https://img3.teletype.in/files/a1/6e/a16ec0b3-985b-4727-a83f-9b43c59220d8.png"></media:content><category>devops</category><description><![CDATA[<img src="https://img4.teletype.in/files/3e/70/3e704109-3edc-4f8a-8917-92072b983271.png"></img>Как-то так получилось, что “откат изменений” звучит часто, но редко говорят, как он вообще происходит с точки зрения рабочего процесса. Хотя откат — является такой же полноценной частью workflow и тоже в целом попадает в понимание git’a]]></description><content:encoded><![CDATA[
  <p id="Da80">Как-то так получилось, что “<em>откат изменений</em>” звучит часто, но редко говорят, как он вообще происходит с точки зрения рабочего процесса. Хотя откат — является такой же полноценной частью <code>workflow</code> и тоже в целом попадает в понимание <code>git</code>’a</p>
  <p id="XRKW">Первое правило <strong>надёжного релиза</strong> — уметь быстро вернуть систему в рабочее состояние. Отказоустойчивый процесс отката строится на трёх уровнях:</p>
  <ol id="OEcH">
    <li id="Mfzq">управление историей Git,</li>
    <li id="016u">управление артефактами и окружениями,</li>
    <li id="PG4X">управление конфигурациями и инфраструктурой.</li>
  </ol>
  <p id="TbEt">Разные приёмы — от <code>git revert</code> до <strong>blue/green-деплоймента</strong> и <code>feature-флагов</code> — сокращают MTTR (<em>англ. Mean Time To Recovery — среднее время восстановления работоспособности сервиса после сбоя или инцидента</em>) и сводят риски к минимуму.</p>
  <p id="Kmii"></p>
  <section style="background-color:hsl(hsl(236, 74%, var(--autocolor-background-lightness, 95%)), 85%, 85%);">
    <h1 id="lYlq" data-align="center">Какие есть стратегии отката?</h1>
  </section>
  <figure id="3d4I" class="m_column">
    <img src="https://img4.teletype.in/files/3e/70/3e704109-3edc-4f8a-8917-92072b983271.png" width="1024" />
  </figure>
  <ul id="E0PH">
    <li id="P0Cr">Ошибка кода → <strong>Git revert/reset</strong>.</li>
    <li id="aiw6">Сбой инфраструктуры → <strong>Откат артефакта</strong>.</li>
    <li id="REbh">Ошибка конфигурации делится на два сценария:</li>
    <ul id="rNRn">
      <li id="puhO"><strong>Частичная неработоспособность</strong> → <strong>Вкл/выкл функции</strong>.</li>
      <li id="TvyP"><strong>Критический сбой</strong> → <strong>Ветка хотфикса</strong>.</li>
    </ul>
  </ul>
  <p id="pnLQ"></p>
  <section style="background-color:hsl(hsl(236, 74%, var(--autocolor-background-lightness, 95%)), 85%, 85%);">
    <h2 id="il6I" data-align="center">Когда в общем-то нужен откат?</h2>
  </section>
  <h3 id="7Brk">1. Баг после мёржа в master</h3>
  <p id="bQju">После <code>merge</code> новой ветки в <strong><code>master</code></strong> появляется какой-то баг, который ранее уже был исправлен или вообще не встречался. Короче, <strong>старое поведение сломалось из-за нового изменения</strong>.</p>
  <p id="HB4I"><strong>Пример:</strong> добавили новую фичу, и с ней случайно вернули баг, который раньше уже исправили. В результате что-то, что работало, после релиза снова не работает.</p>
  <p id="umnI"></p>
  <h3 id="wUUO"><strong>2. Несовместимый конфиг, упавший pod или ошибочный Helm-чарт</strong></h3>
  <ul id="Gqr6">
    <li id="CiRT"><strong>Несовместимый конфиг</strong> — с ошибками или нерелевантными параметрами, из-за чего сервис не может корректно стартовать.</li>
    <li id="qhqh"><strong>Упавший pod</strong> — в <strong>Kubernetes</strong> <code>pod</code> не стартует или сразу падает из-за вышеуказанных ошибок в конфиге или обновлении.</li>
    <li id="1Zkn"><strong>Ошибочный Helm-чарт</strong> — при деплое через Helm передан <strong>неправильный шаблон или параметры</strong>, сервис не запускается или работает неправильно.</li>
  </ul>
  <p id="ffbh"><strong>Пример:</strong> задеплоили сервис с новым конфигом, в котором неправильно указан адрес базы данных. В результате <strong>pod не стартует, или сразу завершается с ошибкой, или работает некорректно</strong> — все варианты имеют место быть. Всё зависит от деплоймента.</p>
  <p id="PGpg"></p>
  <h3 id="vXQP">3. Неуспешная миграция БД</h3>
  <p id="3c2K">При миграции БД меняется структура базы данных (добавление столбцов, изменение типов данных и т.д.). Неуспешная миграция — изменения к базе <strong>применились некорректно, с ошибками или частично.</strong></p>
  <p id="jpmz"><strong>Пример:</strong> скрипт миграции выполнился не полностью: часть данных потеряна или структура теперь несовместима с приложением — <strong>сервис начинает падать или работать с ошибками.</strong></p>
  <p id="LYvB"></p>
  <h3 id="5UoF"><strong>4. Частичная деградация функциональности, устранимая флагом</strong></h3>
  <p id="5e7I">Частичная деградация — это когда <strong>не весь сервис</strong> перестал работать, а <strong>только</strong> какая-то <strong>функция</strong>, но главная работа продолжается. Если предусмотрены <code>feature flags</code> (<em>флаги фич</em>), проблемную функцию <strong>можно временно отключить, не откатывая весь код.</strong></p>
  <p id="2nca"><strong>Пример:</strong> вышло обновление, и сбоит только недавно добавленный виджет: <strong>можно временно его выключить с помощью конфигурационного флага</strong>, а не возвращать всю систему назад.</p>
  <p id="618W"></p>
  <h3 id="DcOL">Итог:</h3>
  <p id="0O4y">Все эти ситуации — типичные сценарии, когда требуется быстрое реагирование и откаты.</p>
  <section style="background-color:hsl(hsl(236, 74%, var(--autocolor-background-lightness, 95%)), 85%, 85%);">
    <h2 id="75q6" data-align="center">ТЕПЕРЬ ПРО САМИ СТРАТЕГИИ</h2>
  </section>
  <h2 id="b2Nt">Откат в Git</h2>
  <p id="8Lu6"><strong>1. <code>git revert</code> — безопасный откат</strong></p>
  <p id="AYen">Создаёт новый коммит, инверсно повторяющий изменения, сохраняя публичную историю и не ломая чужие репозитории.</p>
  <p id="gBVL"><strong>2. <code>git reset --hard</code> — машина времени</strong></p>
  <p id="JQ6H">Перемещает указатель ветки и рабочее дерево на указанный SHA (хеш коммита), <strong>безвозвратно теряя коммиты.</strong> Допустимо <strong>только в приватных ветках</strong> или с последующим <code>push --force</code>.</p>
  <p id="gXaJ"><strong>Как выбрать приём</strong></p>
  <ul id="ZrA4">
    <li id="EMzx">Публичный репозиторий → <code>revert</code>.</li>
    <li id="msLl">Локальная ветка до push → <code>reset --hard</code>.</li>
  </ul>
  <p id="YmJ0"></p>
  <h2 id="tM7s">Хотфикс-ветки как отдельная дисциплина</h2>
  <p id="eSfN">В <strong>Gitflow</strong> <code>hotfix/*</code> заводятся прямо от <code>master</code>, ограничивая изменения <strong>только баг-фиксом</strong> и после ревью сливать их <strong>одновременно</strong> в <code>master</code> и <code>develop</code>. Это убирает критическую проблему, но <strong>не затрагивает незавершённые фичи и не переписывает историю.</strong></p>
  <figure id="b57p" class="m_column" data-caption-align="center">
    <img src="https://img1.teletype.in/files/0b/97/0b97a3da-68eb-4a93-9df8-47a8d2d386b0.png" width="2464" />
    <figcaption>Git-хотфикс: создание ветки от master, выпуск фикса и обратное слияние в master и develop</figcaption>
  </figure>
  <p id="3A8K"></p>
  <h2 id="ek4h">Откат артефакта на уровне деплоймента</h2>
  <p id="qO55">Артефакт — закрытый, версионируемый результат сборки: <strong>Docker-образ, JAR, Helm-release</strong>. Его тег (commit SHA, semver или build-номер) хранится в <code>registry</code> и подтягивается пайплайном.</p>
  <h3 id="5QLE">В Kubernetes</h3>
  <ul id="iaHM">
    <li id="gFuA"><code>kubectl rollout undo deployment/&lt;name&gt;</code> переключает ReplicaSet на предыдущую ревизию, сохраняя историю внутри объекта Deployment.</li>
    <li id="sL3h">Для Helm — <code>helm rollback &lt;release&gt; &lt;revision&gt;</code>; Helm хранит ревизии-чарты в <code>ConfigMap</code>, что позволяет мгновенно откатиться.</li>
  </ul>
  <h3 id="Trxi">Когда откат артефакта недостаточен</h3>
  <p id="Ri0C">Если баг вызван изменением схемы БД или Terraform-плана, одного перескока контейнера мало — потребуется откат миграции или инфраструктурного состояния.</p>
  <p id="YYkF"></p>
  <h2 id="YoDi">GitOps-подход - откат конфигурации</h2>
  <p id="toX3">В <strong>GitOps-подходе</strong> конфиги Kubernetes/Terraform живут в отдельной репе. Условный ArgoCD синхронизирует кластер с <strong>HEAD репозитория:</strong> достаточно <code>git revert</code> нужного коммита, и контроллер применит <strong>прежнюю манифестацию</strong>. Такой откат затрагивает <strong>только инфраструктуру и не требует перекатывать сам образ.</strong></p>
  <p id="dZV9">Плюс существует подход, при котором в конфиг-репозитории <strong>можно явно указать, какую версию артефакта надо задеплоить.</strong> В таком случае можно выполнить деплой нужной версии, стриггерив пайплайн на изменение в конфиге — он просто возьмёт указанный артефакт и редеплойнет его.</p>
  <p id="k3wT"></p>
  <section style="background-color:hsl(hsl(236, 74%, var(--autocolor-background-lightness, 95%)), 85%, 85%);">
    <h3 id="SyIg" data-align="center">Почему баги просачиваются в <code>master</code> и что с этим делать?</h3>
  </section>
  <figure id="8CdT" class="m_column">
    <img src="https://img3.teletype.in/files/e9/93/e993c4d0-b713-4aa8-96d6-68a9fc1d4744.png" width="1148" />
  </figure>
  <p id="GkY2" data-align="center"><strong>Так что откат — не «план Б», а полноправная часть жизненного цикла доставки.</strong></p>

]]></content:encoded></item><item><guid isPermaLink="true">https://teletype.in/@prosto_devops/ViJIu8-x5BO</guid><link>https://teletype.in/@prosto_devops/ViJIu8-x5BO?utm_source=teletype&amp;utm_medium=feed_rss&amp;utm_campaign=prosto_devops</link><comments>https://teletype.in/@prosto_devops/ViJIu8-x5BO?utm_source=teletype&amp;utm_medium=feed_rss&amp;utm_campaign=prosto_devops#comments</comments><dc:creator>prosto_devops</dc:creator><title>WORKFLOW</title><pubDate>Wed, 09 Jul 2025 21:21:14 GMT</pubDate><media:content medium="image" url="https://img4.teletype.in/files/76/38/7638dae4-ea11-4c03-be3d-06bfae882a99.png"></media:content><description><![CDATA[<img src="https://img3.teletype.in/files/ed/c6/edc6539c-ceb5-4d13-934e-73b8ba934fe4.png"></img>Ещё одно понятие, которое входит в пресловутый git.]]></description><content:encoded><![CDATA[
  <p id="MAtM">Ещё одно понятие, которое входит в пресловутый <code>git</code>. Девопсу очень важно понимать, как работает команда разработчиков.</p>
  <pre id="DEBF">Что входит в понятие workflow:
- Какая модель ветвления
- Как происходит процесс релизов
- Где, как и когда включается CI/CD
</pre>
  <p id="5kDh">В этом посте разберем разные стратегии ветвления.</p>
  <h2 id="vCi7" data-align="center">GITHUB FLOW</h2>
  <p id="rhMP">Это самая простая стратегия ветвления, которая подходит для небольших команд и проектов с частыми релизами.</p>
  <p id="AeYh"><strong>Основные принципы:</strong></p>
  <ul id="MuR8">
    <li id="oAwV">Вся разработка начинается с создания отдельной ветки от <strong><code>master</code></strong> (<strong><code>main</code></strong>).</li>
    <li id="1byw">Каждая новая задача (<code>feature, bugfix, hotfix</code>) реализуется в своей ветке.</li>
    <li id="lR6g">После завершения работы создаётся Pull Request (PR) для ревью.</li>
    <li id="5rxg">После аппрува PR ветка сливается обратно в <strong><code>master</code></strong>.</li>
    <li id="f6nZ">Любой код в <strong><code>master</code></strong> должен быть готов к деплою.</li>
    <li id="PXrr">После слияния изменений в <strong><code>master</code></strong> обычно <strong>сразу</strong> происходит <strong>деплой на продакшен.</strong></li>
  </ul>
  <figure id="a1UC" class="m_column">
    <img src="https://img3.teletype.in/files/ed/c6/edc6539c-ceb5-4d13-934e-73b8ba934fe4.png" width="1553" />
  </figure>
  <h3 id="uxYW">То есть процесс разработки выглядит следующим образом:</h3>
  <p id="0DRL">Отбранчуется ветка от мастера, там ведется нужная разработка, когда разработка завершена → Pull request, ревью, апрув, мердж в мастер и деплой.</p>
  <p id="MNh2">За счет своей простоты этот флоу лучше всех остальных для полного автоматического CI/CD. Процесс максимально прозрачный и понятный. Но есть и минусы:</p>
  <ul id="pfdD">
    <li id="EWxo">Не подходит для поддержки нескольких версий продукта.</li>
    <li id="q1Dm">Нет отдельной ветки со <strong>стабильной версией</strong> — возможны баги в проде.</li>
  </ul>
  <h2 id="VAGW" data-align="center">GitFlow</h2>
  <p id="5yKH">Классическая, очень популярная и более сложная стратегия. <strong>Подходит для крупных проектов с релизными циклами и необходимостью поддержки нескольких версий.</strong></p>
  <p id="YLgf"><strong>Структура ветвления:</strong></p>
  <ul id="sJVK">
    <li id="ppbK"><strong><code>master</code></strong> (<code>main</code>) всегда содержит только стабильный и релизный код.</li>
    <li id="6lz2"><strong><code>develop</code> -</strong> основная ветка для интеграции новых фичей перед релизом.</li>
    <li id="L0Lo"><strong><code>feature/*</code></strong> ветки для разработки новых фичей, создаются от <strong><code>develop</code></strong>, после завершения сливаются обратно в <strong><code>develop</code></strong>.</li>
    <li id="4OsL"><strong><code>release/*</code></strong> ветки для подготовки релиза, создаются от <strong><code>develop</code></strong>, после релиза сливаются в <strong><code>master</code></strong> и <strong><code>develop</code></strong>.</li>
    <li id="YJJL"><strong><code>hotfix/*</code></strong> для срочных исправлений в проде, создаются от <strong><code>master</code></strong> , после фикса сливаются в <strong><code>master</code></strong> и <strong><code>develop</code></strong>.</li>
  </ul>
  <figure id="KQFE" class="m_column">
    <img src="https://img4.teletype.in/files/f5/70/f570f72f-f1c0-4f91-8c33-169fbdb002dd.png" width="1554" />
  </figure>
  <h3 id="SUr1"><strong>А вот так выглядит процесс разработки:</strong></h3>
  <p id="QK1z"><strong>1. Создание фичи</strong></p>
  <ul id="gALI">
    <li id="vmBk">От основной ветки разработки (<code>develop</code>) создаётся отдельная ветка для новой фичи</li>
    <li id="7qS3">Вся работа над задачей ведётся только в этой ветке.</li>
  </ul>
  <p id="hEkQ"><strong>2. Завершение работы над фичей</strong></p>
  <ul id="8SPe">
    <li id="AgGU">Когда завершили работу, фича-ветка сливается обратно в <code>develop</code> (обычно через Merge Request/Pull Request и ревью)</li>
  </ul>
  <p id="wN9H"><strong>3. Деплой в dev-окружение</strong></p>
  <ul id="pHgE">
    <li id="Csvj">После слияния фичи в <code>develop</code> обычно автоматически запускается CI/CD пайплайн для <strong>деплоя на dev-сервер.</strong></li>
    <li id="O5OW">Изменения тестируются в dev-окружении.</li>
  </ul>
  <p id="Uxwq"><strong>4. Подготовка релиза</strong></p>
  <ul id="Qb2D">
    <li id="AR4p">Когда накопилось достаточно изменений, создаётся ветка релиза</li>
    <li id="sY64">В релизной ветке фиксируются баги, обновляются версии, документация и т.д.</li>
  </ul>
  <p id="qOhP"><strong>5. Деплой релиза в dev/stage</strong></p>
  <ul id="8ZZM">
    <li id="7zGr">Ветка <code>release/x.y.z</code> <strong>деплоится на</strong> <code>stage/dev</code> <strong>для финального тестирования.</strong></li>
    <li id="gHR9">Вносятся последние правки, багфиксы <strong>коммитятся прямо в релизную ветку.</strong></li>
  </ul>
  <p id="oKZV"><strong>6. Выпуск релиза (деплой в прод)</strong></p>
  <ul id="bReM">
    <li id="ugAJ">Если протестировали и <strong>всё ок </strong>- релизная ветка сливается в <code>master</code> (<code>main</code>):</li>
    <li id="184d">Также изменения из релизной ветки вливаются обратно в <code>develop</code>, чтобы не потерять фиксы</li>
    <li id="l185">Релиз тегируется (<code>условно 1.0.1</code>)</li>
    <li id="9eY1">CI/CD деплоит код из <code>master</code> на прод.</li>
  </ul>
  <p id="wbQO">Этот подход к ветвлению обеспечивает четкое разделение стадий (фича, дев, релиз, мастер), на каждом этапе всё безопасно тестируется, в случае чего легко можно сделать откат, плюс есть возможность иметь несколько версий приложения. Но, здесь CI/CD уже не такой простой, как в GitHub flow, так как веток больше, есть разные окружения, тестирование в них и сборки релизов.</p>
  <h2 id="AdlF" data-align="center">GitLab FLOW</h2>
  <p id="w5vq">Это нечто среднее, между <code>github flow</code> и <code>gitflow</code>. Стратегия вариативная, можно подстроить под разные процессы. Можно сказать взяли лучшее из двух: простоту и структурность.</p>
  <p id="3uPA"><strong>Ключевые особенности:</strong></p>
  <ul id="fzYf">
    <li id="yDjx">Основная ветка (<strong><code>main</code></strong> или <strong><code>master</code></strong>) с продакшен-кодом.</li>
    <li id="TVO5">Для новых задач создаются feature-ветки, которые после ревью вливаются в <strong><code>master</code></strong>.</li>
    <li id="MdEn">Возможны дополнительные ветки для разных окружений: <strong><code>staging</code></strong>, <strong><code>production</code></strong>, <strong><code>pre-production</code></strong>.</li>
    <li id="gpP9">Можно использовать <em>issue-трекинг</em> и <em>merge requests</em> для управления задачами.</li>
    <li id="lLCn">Опционально можно внедрить релизные ветки для версионирования</li>
  </ul>
  <figure id="y4ie" class="m_column" data-caption-align="center">
    <img src="https://img4.teletype.in/files/b2/b7/b2b7acd2-c584-4f78-8eb1-a19087c1e66c.png" width="3390" />
    <figcaption>Не стали рисовать схему, взяли картинку в интернете)</figcaption>
  </figure>
  <p id="wux3"><strong>У GitLab Flow есть две основные вариации:</strong></p>
  <ul id="UP7H">
    <li id="4tFO"><strong>Environment branches,</strong> то есть отдельные ветки для разных сред (тот же <strong><code>staging</code></strong>). Код <strong>последовательно проходит через эти ветки по мере тестирования и релиза.</strong></li>
    <li id="5jJp"><strong>Release branches.</strong> Этот вариант нужен для поддержки <strong>нескольких версий продукта.</strong> Можно создавать ветки <strong><code>v1</code></strong>, <strong><code>v2</code></strong> и т.д., в которые попадают <strong>только нужные изменения</strong> (например, багфиксы через <code>cherry-pick</code>).</li>
  </ul>
  <p id="Bz9J">Этот флоу можно адаптировать под любой процесс, он легко интегрируется с CI/CD. Самое главное - договорённости внутри команды по правилам ветвления и релизов. Это всё тщательно описывается, чтобы все понимали с чем и как они работают.</p>
  <h3 id="ul2f"><strong>Отдельно рассмотрим GitLab flow с версионированием.</strong></h3>
  <p id="sLLI">Работает это так:</p>
  <ul id="XxZQ">
    <li id="v4XI">Для каждой поддерживаемой версии создаётся отдельная ветка (<strong><code>v1</code></strong>, <strong><code>v2</code></strong> и т.д.).</li>
    <li id="QWbd">Новые фичи и багфиксы сначала попадают в основную ветку разработки (<strong><code>master</code></strong> или <strong><code>develop</code></strong>), затем нужные изменения <code>cherry-pick</code>&#x27;ом переносятся в ветки соответствующих версий.</li>
    <li id="m3EK">Подход позволяет исправлять баги в старых версиях, <strong>не внедряя туда новые фичи.</strong></li>
  </ul>
  <figure id="n8Xi" class="m_column">
    <img src="https://img4.teletype.in/files/bd/be/bdbeaf1f-ba78-409c-bce9-77b1e6f0c809.png" width="1554" />
  </figure>
  <p id="GBTH">Сложность заключается именно в поддержании релизов и долгосрочной поддержкой нескольких версий, всё надо тщательно перепроверять при переносе изменений между ветками версий</p>
  <h2 id="XzeX" data-align="center">Trunk-based Development</h2>
  <p id="F8pJ">Trunk в переводе с английского в нашем контексте - ствол. На картинке видно, почему он имеет именно такое название.</p>
  <p id="2JYr">Основное тут у нас - частые и маленькие коммиты в одну общую ветку <strong><code>trunk</code></strong> (или <strong><code>master</code></strong>)</p>
  <figure id="Pqyn" class="m_column">
    <img src="https://img2.teletype.in/files/de/14/de14b9cd-c2a4-49e1-bd18-d6f0f4ccda0c.png" width="1554" />
  </figure>
  <p id="5RUA"><strong>Особенности:</strong></p>
  <ul id="ajXr">
    <li id="aB1A">Все разработчики работают <strong>с одной основной веткой</strong>, feature-ветки живут не дольше пары дней (в идеальной картине - не более 24 часов)</li>
    <li id="xmJP">Ветки быстро сливаются обратно в <strong><code>trunk</code></strong></li>
    <li id="10Ts">CI/CD обложен огромной кучей автотестов. И если другие стратегии хоть как-то можно представить без автоматического CI/CD (и то с натяжкой), то здесь это просто невозможно</li>
    <li id="IZbA">Если нужны релизные ветки, они создаются <strong>только для стабилизации и поддержки релиза</strong>, а не для долгой разработки</li>
  </ul>
  <p id="4fxB"><strong>Самый главный плюс</strong> - максимальная скорость релизов. Из минусов (или особенностей) - здесь должен быть максимально высокий уровень автоматического тестирования. И этот флоу <strong>не подходит</strong> для продуктов, где надо поддерживать несколько версий.</p>
  <p id="GzAZ">Так сказать продолжаем раскрывать тему гита, кстати в <a href="https://t.me/tribute/app?startapp=sqBy" target="_blank">закрытом канале есть большое видео про разные флоу разработки.</a></p>

]]></content:encoded></item></channel></rss>