WEBVTT

00:00:00.000 --> 00:00:04.880
Тема сегодняшнего выпуска – то, о чем слышали почти все, но мало кто может действительно объяснить.

00:00:05.080 --> 00:00:09.720
GitOps. Вы наверняка видели это упоминание в описаниях вакансий, на конференциях или в документации АЗУ.

00:00:09.820 --> 00:00:14.900
Но что же это такое на самом деле? Это просто очередной модный термин в DevOps или нечто принципиально иное?

00:00:15.080 --> 00:00:21.400
Вот краткая суть. GitOps – это операционная модель, в которой Git становится единственным источником истины для всей вашей инфраструктуры,

00:00:21.580 --> 00:00:24.360
не только для кода приложений, но и для всего, что его запускает.

00:00:24.360 --> 00:00:27.760
К концу этого выпуска вы поймете, что такое GitOps на самом деле,

00:00:27.760 --> 00:00:32.920
почему он стал стандартом управления Kubernetes в Azure и как он делает откат изменений простой командой.

00:00:33.180 --> 00:00:36.360
Старый подход – ручное развертывание и расхождение конфигураций.

00:00:36.540 --> 00:00:38.660
Давайте начнем с проблемы, которую решает GitOps.

00:00:38.820 --> 00:00:41.380
Представьте, что вы управляете кластером Kubernetes в Azure.

00:00:41.560 --> 00:00:44.900
Ваши разработчики отправляют код, CI-конвейер собирает образы контейнеров,

00:00:45.080 --> 00:00:47.760
а кто-то запускает кубик TlApply для развертывания этих образов.

00:00:47.880 --> 00:00:50.860
Может быть, это вы, ваш коллега или нажатие кнопки в Azure DefOps.

00:00:51.040 --> 00:00:52.340
В любом случае, деплей происходит.

00:00:52.340 --> 00:00:54.680
Это работает хорошо, пока не перестает работать.

00:00:54.840 --> 00:00:55.960
Вот что происходит дальше.

00:00:55.960 --> 00:00:59.420
Кто-то из команды хочет быстро исправить баг, подключается по SSH к узлу,

00:00:59.580 --> 00:01:02.940
использует портал Azure или запускает кубик TlEdit напрямую для развертывания.

00:01:03.140 --> 00:01:06.960
Вносится небольшое изменение, например, правка конфиг-карты или смена переменной окружения,

00:01:07.120 --> 00:01:08.320
и кажется, что все безобидно.

00:01:08.420 --> 00:01:09.940
По крайней мере, они так думают.

00:01:10.080 --> 00:01:12.080
Проблема в том, что изменение не попало в Git,

00:01:12.220 --> 00:01:16.060
поэтому теперь конфигурация вашего кластера не совпадает с тем, что лежит в репозитории.

00:01:16.220 --> 00:01:18.200
Это называется расхождением конфигураций.

00:01:18.340 --> 00:01:21.760
Это расхождение – тихий убийца, потому что все работает нормально до следующего развертывания,

00:01:21.760 --> 00:01:25.300
когда кто-то запускает кубик TlApply с исходным манифестом и затирает это быстрое исправление.

00:01:25.500 --> 00:01:29.380
Или, что еще хуже, расхождение вызывает непредвиденное поведение, которое никто не может объяснить.

00:01:29.540 --> 00:01:33.280
Вы начинаете отладку, проверяете логи, смотрите в IML в Git, все выглядит нормально,

00:01:33.500 --> 00:01:34.640
но кластер ведет себя иначе.

00:01:34.760 --> 00:01:37.760
Вы понятия не имеете, что изменилось, когда и кто это сделал.

00:01:37.920 --> 00:01:38.880
Я сам такое видел.

00:01:38.880 --> 00:01:44.480
Коллега подключается по SSH к узлу, меняет конфиг для теста, забывает вернуть все обратно и уходит домой.

00:01:44.640 --> 00:01:47.980
На следующий день развертывание ломается, и никто не понимает, почему.

00:01:48.280 --> 00:01:53.400
Репозиторий Git выглядит чистым, а в кластере – беспорядок, и вы часами пытаетесь понять, что же случилось.

00:01:53.540 --> 00:01:54.380
Итак, вопрос.

00:01:54.600 --> 00:01:58.380
Что если бы существовал способ заставить кластер всегда соответствовать тому, что находится в Git?

00:01:58.500 --> 00:02:02.740
Что если бы вы могли гарантировать, что все, что лежит в вашем репозитории, в точности соответствует тому, что работает в продакшене?

00:02:02.820 --> 00:02:04.420
Это и есть основная идея GitOps.

00:02:04.620 --> 00:02:06.160
Что же такое GitOps на самом деле?

00:02:06.340 --> 00:02:07.800
Итак, что же такое GitOps?

00:02:07.800 --> 00:02:10.260
Вот самое простое определение, которое я могу дать.

00:02:10.420 --> 00:02:15.400
Git становится единым источником истины не только для вашего кода, но и для всего, что необходимо для работы вашей инфраструктуры.

00:02:15.580 --> 00:02:20.260
Любая конфигурация, любой манифест развертывания, любое переменное окружение – все это хранится в Git.

00:02:20.360 --> 00:02:23.000
В вашем кластере не запустится ничего, если оно там не определено.

00:02:23.160 --> 00:02:25.180
GitOps – это не инструмент, который можно купить.

00:02:25.300 --> 00:02:27.860
Это операционная модель, подобная DevOps или DevSecOps.

00:02:28.040 --> 00:02:31.060
Набор принципов, которые определяют, как вы управляете инфраструктурой.

00:02:31.200 --> 00:02:35.140
Стандарт OpenGitOps выделяет четыре основных принципа, и я хочу разобрать каждый из них.

00:02:35.140 --> 00:02:37.460
Во-первых, ваша система должна быть декларативной.

00:02:37.460 --> 00:02:40.920
Это означает, что вы описываете конечное состояние, а не шаги для его достижения.

00:02:41.040 --> 00:02:45.760
То есть вместо написания скрипта, который создает развертывание, масштабирует его до пяти реплик и открывает порт 8080,

00:02:45.940 --> 00:02:50.740
вы пишете в IML файл, в котором говорите «хочу пять реплик на порту 8080», а система сама определяет шаги.

00:02:50.820 --> 00:02:52.040
И это и есть декларативность.

00:02:52.220 --> 00:02:53.900
Во-вторых, все должно быть версионировано.

00:02:54.060 --> 00:02:56.620
Каждое изменение, которое вы вносите в состояние кластера, является коммитом в Git.

00:02:56.740 --> 00:02:59.280
Таким образом, вы получаете полную историю, кто, что, когда и зачем изменил.

00:02:59.420 --> 00:03:01.160
Больше никаких догадок или копания в логах.

00:03:01.160 --> 00:03:03.200
В-третьих, изменения подтягиваются автоматически.

00:03:03.320 --> 00:03:05.520
Кластер сам обращается к Git, чтобы увидеть, что нового.

00:03:05.640 --> 00:03:07.320
Позже я объясню, почему это так важно.

00:03:07.480 --> 00:03:09.720
И в-четвертых, система постоянно синхронизируется.

00:03:09.940 --> 00:03:14.320
Внутри вашего кластера работает программный агент, который постоянно сравнивает то, что в Git, с тем, что работает на самом деле.

00:03:14.480 --> 00:03:16.520
Если они не совпадают, он устраняет расхождение.

00:03:16.680 --> 00:03:18.100
Это и есть цикл синхронизации.

00:03:18.400 --> 00:03:19.200
Представьте это так.

00:03:19.340 --> 00:03:21.020
Git — это чертеж вашего архитектора.

00:03:21.200 --> 00:03:23.440
В нем точно описано, как должно выглядеть здание.

00:03:23.820 --> 00:03:25.620
Кубернетес — это строительная площадка.

00:03:25.720 --> 00:03:27.360
А GitOps оператор — это прорав.

00:03:27.360 --> 00:03:30.840
Он ходит с чертежом, проверяя каждую стену, каждую балку, каждое окно.

00:03:31.000 --> 00:03:33.020
Если что-то не совпадает, он это исправляет.

00:03:33.160 --> 00:03:37.120
Допустим, кто-то из бригады вносит несанкционированные изменения, он замечает их и отменяет.

00:03:37.240 --> 00:03:39.240
Чертеж всегда является источником истины.

00:03:39.360 --> 00:03:41.100
Но именно здесь происходит настоящий сдвиг.

00:03:41.200 --> 00:03:43.000
То, как работают развертывания на самом деле.

00:03:43.120 --> 00:03:45.920
В традиционном CI, CD вы проталкиваете изменения в кластер.

00:03:46.020 --> 00:03:47.820
В GitOps кластер забирает их сам.

00:03:47.980 --> 00:03:49.420
И эта разница важнее, чем кажется.

00:03:49.660 --> 00:03:52.660
Развертывание на основе получения — пул против развертываний на основе отправки — пуш.

00:03:52.780 --> 00:03:54.780
Давайте поговорим о том, как работают развертывания.

00:03:54.780 --> 00:03:56.680
Потому что именно здесь GitOps меняет все.

00:03:56.820 --> 00:03:59.740
В традиционной модели push-в-HCI конвейер делает все.

00:03:59.900 --> 00:04:02.760
Azure Pipelines Jenkins GitHub Actions.

00:04:02.960 --> 00:04:08.180
Он собирает контейнер, запускает тесты, а затем отправляет этот образ напрямую в ваш кубернет из кластера.

00:04:08.320 --> 00:04:11.880
Конвейер хранит учетные данные, обеспечивающие прямой доступ к API-кластеру.

00:04:12.040 --> 00:04:13.940
Он сообщает, вот новое развертывание.

00:04:14.100 --> 00:04:15.200
Примените его сейчас.

00:04:15.360 --> 00:04:17.760
Это работает, но создает проблему безопасности.

00:04:17.960 --> 00:04:21.920
Суть в том, что если конвейер будет скомпрометирован, кто-то добавит вредоносный шаг,

00:04:21.920 --> 00:04:27.080
утечет токен или будет взломана зависимость, у него появится прямой доступ к вашему продуктовому кластеру.

00:04:27.260 --> 00:04:30.840
Он может разрушить развертывание, удалить пространство имен, изменить конфигурации,

00:04:30.980 --> 00:04:33.120
используя все те права, которые вы ему предоставили.

00:04:33.260 --> 00:04:34.800
Теперь взгляните на модель GitOps.

00:04:35.000 --> 00:04:36.100
Процесс начинается так же.

00:04:36.300 --> 00:04:37.940
CI собирает контейнер и отправляет его в реестр.

00:04:38.080 --> 00:04:39.280
Например, Azure Container Registry.

00:04:39.420 --> 00:04:40.840
На этом работа CI заканчивается.

00:04:41.000 --> 00:04:42.140
Он не касается кластера.

00:04:42.340 --> 00:04:45.460
Вместо этого CI обновляет Git репозиторий с новым тегом образа.

00:04:45.580 --> 00:04:49.740
Он изменяет одну строку в IML файле, версию образа и фиксирует это изменение.

00:04:49.740 --> 00:04:52.140
Вот и все. Никакого прямого доступа к кластеру.

00:04:52.300 --> 00:04:55.360
Затем GitOps оператор, работающий внутри вашего кластера, видит это изменение.

00:04:55.500 --> 00:04:57.860
Он забирает актуальное состояние из Git и применяет его.

00:04:58.000 --> 00:04:59.900
Кластер сам обращается к Git, а не наоборот.

00:05:00.080 --> 00:05:02.100
Это модель, основанная на вытягивании Pool Basset.

00:05:02.260 --> 00:05:04.460
Ваш кластер никогда не открывает свой API для внешних систем.

00:05:04.640 --> 00:05:05.960
Он только получает данные из Git.

00:05:06.140 --> 00:05:08.600
Если кто-то взломает ваш CI-конвейер, максимум, что он сможет сделать,

00:05:08.720 --> 00:05:09.700
изменить манифест в репозитории.

00:05:09.840 --> 00:05:11.580
Он не сможет напрямую воздействовать на кластер.

00:05:11.700 --> 00:05:13.460
Оператор сам решает, что и когда применять.

00:05:13.620 --> 00:05:14.860
Есть еще одно преимущество.

00:05:14.860 --> 00:05:16.580
Вы разделяете сборку и развертывание.

00:05:16.740 --> 00:05:19.300
CI делает-то. В чем он хорош? Сборку, тестирование, сканирование.

00:05:19.480 --> 00:05:21.140
GitOps оператор берет на себя развертывание.

00:05:21.300 --> 00:05:23.040
Каждая система фокусируется на своей задаче.

00:05:23.200 --> 00:05:25.200
Если сборка не удалась, в кластере ничего не меняется.

00:05:25.340 --> 00:05:28.040
Если развертывание не удалось, оператор повторяет попытку или оповещает вас.

00:05:28.140 --> 00:05:29.040
Четкое разделение.

00:05:29.240 --> 00:05:31.820
Итак, вместо того, чтобы конвейер проталкивал изменения в кластер,

00:05:31.960 --> 00:05:33.860
кластер сам забирает желаемое состояние из Git.

00:05:33.960 --> 00:05:36.900
Эта простая инверсия делает вашу инфраструктуру безопаснее,

00:05:37.100 --> 00:05:39.800
прозрачнее для аудита и ее сложнее случайно сломать.

00:05:40.400 --> 00:05:41.520
Цикл согласования.

00:05:41.520 --> 00:05:44.300
Итак, как оператор узнает, когда нужно обновиться?

00:05:44.460 --> 00:05:45.540
Он не ждет уведомлений.

00:05:45.720 --> 00:05:48.500
Он запускает непрерывный цикл, следит за Git, сравнивает с кластером,

00:05:48.660 --> 00:05:52.000
применяет изменения при необходимости, а затем делает это снова и снова бесконечно.

00:05:52.140 --> 00:05:53.760
Это называется циклом согласования.

00:05:53.940 --> 00:05:57.660
Он работает постоянно, каждые несколько секунд или минут, в зависимости от ваших настроек.

00:05:57.820 --> 00:05:59.540
Оператор никогда не прекращает наблюдение.

00:05:59.720 --> 00:06:01.480
Представьте это как термостат в вашем доме.

00:06:01.600 --> 00:06:04.360
Вы устанавливаете желаемую температуру, скажем, 21 градус.

00:06:04.480 --> 00:06:06.720
Термостат постоянно проверяет фактическую температуру.

00:06:06.840 --> 00:06:09.080
Если она падает ниже 21, включается отопление.

00:06:09.080 --> 00:06:11.060
Если поднимается выше, отопление выключается.

00:06:11.060 --> 00:06:13.440
Он продолжает корректировать работу, чтобы соответствовать вашим настройкам.

00:06:13.600 --> 00:06:15.200
GitOps оператор работает точно так же.

00:06:15.360 --> 00:06:17.900
Git хранит желаемое состояние, кластер — фактическое,

00:06:18.020 --> 00:06:20.240
а оператор непрерывно сравнивает их и вносит коррективы.

00:06:20.320 --> 00:06:23.400
Итак, что произойдет, если кто-то вручную изменит развертывание в кластере?

00:06:23.540 --> 00:06:26.380
Например, запустит кубик TellEdit, чтобы изменить количество реплик.

00:06:26.500 --> 00:06:29.600
Оператор обнаружит это расхождение во время следующего цикла согласования.

00:06:29.780 --> 00:06:32.220
В кластере теперь три реплики, а в Git указано пять.

00:06:32.320 --> 00:06:35.920
Поэтому оператор применит состояние, определенное в Git, и в кластере снова станет пять реплик.

00:06:36.220 --> 00:06:37.740
Несанкционированное изменение будет отменено.

00:06:37.860 --> 00:06:39.800
А что произойдет, если вы отправите изменение в Git?

00:06:39.900 --> 00:06:40.580
Тот же процесс.

00:06:40.800 --> 00:06:42.800
Оператор обнаружит разницу и применит ее.

00:06:43.000 --> 00:06:47.440
Разработчик объединяет пиар, который обновляет версию образа с V1, 2, 2, 1, 3.

00:06:47.600 --> 00:06:51.620
Оператор видит новый манифест, подтягивает новый образ и запускает новые поды.

00:06:51.760 --> 00:06:54.520
За считанные секунды состояние кластера снова совпадает с Git.

00:06:54.680 --> 00:06:56.420
Здесь важно провести четкую грань.

00:06:56.480 --> 00:06:58.500
Если подпадает, оператора это не волнует.

00:06:58.600 --> 00:07:01.580
Это работа Kubernetes, которую выполняет контроллер набора реплик.

00:07:01.760 --> 00:07:04.100
GitOps оператор заботится только о конфигурации.

00:07:04.100 --> 00:07:11.800
Если в манифесте развертывания указаны пять реплик и образ V1, 3, и в кластере работают пять реплик V1, 3, оператор спокоен.

00:07:11.960 --> 00:07:14.240
Ему все равно, перезагрузился ли конкретный под.

00:07:14.360 --> 00:07:16.000
Это нормальное поведение Kubernetes.

00:07:16.240 --> 00:07:20.880
Но если кто-то меняет манифест в Git или напрямую меняет кластер, создавая расхождение, оператор начинает действовать.

00:07:21.060 --> 00:07:23.120
Именно это делает GitOps самовосстанавливающимся.

00:07:23.280 --> 00:07:27.560
Он не просто развертывает изменения, он активно предотвращает отклонение инфраструктуры от заданного состояния.

00:07:27.700 --> 00:07:30.380
Итак, вам нужен GitOps оператор, работающий в вашем кластере.

00:07:30.560 --> 00:07:32.920
Именно здесь на помощь приходят ArgoCD и Flacos.

00:07:32.920 --> 00:07:34.420
ArgoCD против Flacos.

00:07:34.540 --> 00:07:39.120
Итак, вам нужен GitOps оператор, и у вас есть два основных выбора, оба отличные.

00:07:39.280 --> 00:07:46.400
ArgoCD и Flacos — это проекты уровня CNCF, что означает, что они прошли высшую проверку на стабильность, сообщество и готовность к продакшну.

00:07:46.540 --> 00:07:49.040
Но они подходят к одной и той же задаче с разных сторон.

00:07:49.240 --> 00:07:52.860
ArgoCD был изначально создан компанией Intuit, и он поставляется с веб-интерфейсом.

00:07:52.980 --> 00:07:59.460
При установке ArgoCD вы получаете панель мониторинга, где можно видеть каждое приложение, статус синхронизации, работоспособность и историю развертываний.

00:07:59.460 --> 00:08:04.780
Вы можете переключаться между ними, просматривать различия между Git и кластером, запускать процессы вручную и одобрять изменения.

00:08:04.920 --> 00:08:08.600
Он предназначен для команд, которым нужны визуальные панели и точки ручного управления.

00:08:08.800 --> 00:08:11.160
Flacos пришел из UI Workus, и он более модульный.

00:08:11.260 --> 00:08:13.300
По умолчанию в нем нет пользовательского интерфейса.

00:08:13.440 --> 00:08:16.820
Вы работаете через командную строку и определяете все как пользовательские ресурсы Kubernetes.

00:08:17.080 --> 00:08:23.160
Вы создаете объект GitRepository, который говорит «следи за этим репозиторием», и объект Настройки, который говорит «применить этот путь».

00:08:23.160 --> 00:08:25.400
Flacos подхватывает его и выполняет синхронизацию.

00:08:25.400 --> 00:08:29.280
Это заставляет использовать Git-ориентированные рабочие процессы, так как здесь нет панели управления.

00:08:29.420 --> 00:08:31.360
А теперь о том, что важно для пользователей Azure.

00:08:31.520 --> 00:08:34.560
Flacos — это стандартный GitOps-инструмент в Azure Kubernetes Service.

00:08:34.720 --> 00:08:37.540
Microsoft создала встроенную интеграцию на базе Flacos V2.

00:08:37.740 --> 00:08:42.020
Когда вы включаете GitOps в кластере AKS через портал Azure, под капотом используется Flacos.

00:08:42.180 --> 00:08:44.960
Azure Arc также использует Flacos для управления множеством кластеров.

00:08:45.080 --> 00:08:48.060
Поэтому для инженеров Azure именно Flacos — это естественная точка отсчета.

00:08:48.200 --> 00:08:49.980
Но у Argo CD есть свои преимущества.

00:08:50.120 --> 00:08:54.680
Он более популярен в платформенной инженерии, где нужна центральная панель управления для множества кластеров.

00:08:54.680 --> 00:08:58.280
Интерфейс упрощает работу командам, которые не привыкли к командной строке.

00:08:58.380 --> 00:09:04.020
Он тесно интегрируется с Argo Rollouts для прогрессивной доставки, например, канари развертываний или Blue Green Scheme.

00:09:04.180 --> 00:09:09.560
Ключевое архитектурное различие в том, что Argo CD работает как отдельное приложение со своим API-сервером.

00:09:09.720 --> 00:09:14.040
Flacos работает как набор Kubernetes-контролеров, глубже встроенных в сам кластер.

00:09:14.160 --> 00:09:19.740
Flacos ощущается как часть Control Plane Kubernetes, а Argo CD — как отдельная платформа поверх него.

00:09:19.880 --> 00:09:24.120
Flacos также активно опирается на Customize, который является родным инструментом шаблонизации Kubernetes.

00:09:24.120 --> 00:09:27.440
Argo CD может использовать Customize, Helm или обычный YML.

00:09:27.600 --> 00:09:31.920
Оба поддерживают Helm, но у Flacos есть отдельный Helm-контроллер для нативной обработки релизов.

00:09:32.060 --> 00:09:35.440
Здесь нет неправильного выбора. Оба инструмента выполняют одну и ту же задачу.

00:09:35.520 --> 00:09:38.300
Но для инженеров Azure путь наименьшего сопротивления — это Flacos.

00:09:38.480 --> 00:09:43.900
Можно включить GitOps с Flacos в несколько кликов на портале Azure, указать репозиторий Git, и синхронизация начнется.

00:09:44.120 --> 00:09:46.940
Никакой дополнительной установки и серверов для обслуживания.

00:09:47.180 --> 00:09:50.460
GitOps в Azure, AKS, Azure Arc и Azure DefOps.

00:09:50.460 --> 00:09:53.420
Итак, как это выглядит на практике при интеграции с Azure?

00:09:53.580 --> 00:09:54.660
Начнем с AKS.

00:09:54.820 --> 00:09:58.840
В Azure Kubernetes сервис встроена поддержка GitOps с использованием Flacos V2.

00:09:59.040 --> 00:10:05.120
На портале Azure перейдите к своему кластеру, найдите раздел GitOps и настройте его, указав репозиторий Git.

00:10:05.260 --> 00:10:07.440
Azure Repos, GitHub, где угодно.

00:10:07.640 --> 00:10:12.420
Flacos начинает следить, и любые манифесты из этого репозитория автоматически применяются к кластеру.

00:10:12.580 --> 00:10:14.440
Но AKS — это лишь часть целого.

00:10:14.440 --> 00:10:19.740
Azure Arc расширяет возможности GitOps на кластеры вне Azure, локальные, в других облаках или на периферии.

00:10:19.880 --> 00:10:23.700
Подключите их к Azure Arc, и вы сможете управлять всеми ими через одну и ту же GitOps конфигурацию.

00:10:23.880 --> 00:10:26.340
Один репозиторий, много кластеров, единое состояние везде.

00:10:26.540 --> 00:10:27.380
Вот в чем суть ARC.

00:10:27.520 --> 00:10:29.260
А теперь поговорим о конвейере, пайплайне.

00:10:29.420 --> 00:10:32.800
Azure DefOps естественным образом интегрируется с этой моделью, и вот распространенный шаблон.

00:10:33.000 --> 00:10:37.280
Ваш исходный код находится в Azure Repos или GitHub, а Azure Pipelines отвечает за CI.

00:10:37.440 --> 00:10:43.260
Он создает образ контейнера, запускает тесты, сканирует на наличие уязвимостей и отправляет образ в Azure Container Registry.

00:10:43.260 --> 00:10:50.020
Затем конвейер обновляет манифесты в вашем GitOps репозитории, меняя тег образа с версии 1, 2 на 1, 3, фиксирует это изменение и отправляет его.

00:10:50.180 --> 00:10:50.640
Вот и все.

00:10:50.800 --> 00:10:53.120
Конвейер никогда не взаимодействует с кластером напрямую.

00:10:53.280 --> 00:10:59.260
Flacus, запущенный внутри EKS, обнаруживает изменения в Git, подтягивает новый манифест, видит обновленный тег образа и применяет развертывание.

00:10:59.460 --> 00:11:01.260
Запускаются новые поды, и кластер синхронизируется.

00:11:02.060 --> 00:11:05.240
Если хотите, можете использовать Git Hub Actions вместо Azure Pipelines.

00:11:05.480 --> 00:11:06.720
Шаблон остается прежним.

00:11:06.900 --> 00:11:11.300
CI отвечает за сборку и обновление манифестов, а GitOps оператор — за развертывание.

00:11:11.300 --> 00:11:13.700
Инструмент не имеет значения, важна модель.

00:11:13.860 --> 00:11:14.800
Вот важная деталь.

00:11:14.980 --> 00:11:19.820
Никогда не храните секреты непосредственно в Git, ни ключи API, ни строки подключения, ни сертификаты.

00:11:20.020 --> 00:11:22.620
Даже в приватном репозитории секреты в Git — это риск.

00:11:22.740 --> 00:11:26.060
Вместо этого используйте Azure Key Vault или оператор внешних секретов.

00:11:26.180 --> 00:11:31.320
Манифест ссылается на секрет по имени, а оператор извлекает фактическое значение из хранилища во время развертывания.

00:11:31.500 --> 00:11:33.720
Вы также можете добавить политику поверх всего этого.

00:11:33.900 --> 00:11:40.160
Azure Policy с GitKipir может применять правила, например, запрещать привилегированные контейнеры или разрешать использование только утвержденных реестров.

00:11:40.160 --> 00:11:45.500
Если кто-то попытается развернуть манифест, нарушающий политику, GitKipir заблокирует его до того, как он попадет в кластер.

00:11:45.620 --> 00:11:47.740
Реальное преимущество здесь — это масштабируемость.

00:11:47.940 --> 00:11:51.360
Имея 50 кластеров AKS, вам не нужно управлять каждым из них по отдельности.

00:11:51.560 --> 00:11:56.800
Определите желаемое состояние в одном Git-репозитории, и каждый кластер будет приводиться к этому состоянию.

00:11:56.980 --> 00:12:00.560
Добавьте новый кластер, укажите ему репозиторий, и он настроит себя сам.

00:12:00.560 --> 00:12:02.920
Нужно обновить конфигурацию во всех кластерах.

00:12:03.060 --> 00:12:05.960
Измените один файл в Git, а операторы сделают все остальное.

00:12:06.160 --> 00:12:08.220
В этом заключается обещание GitOps в Azure.

00:12:08.400 --> 00:12:11.800
Один источник истины, множество кластеров, никакого расхождения конфигураций.

00:12:11.940 --> 00:12:13.040
Ключевые преимущества.

00:12:13.220 --> 00:12:16.600
Итак, все это звучит хорошо в теории, но что это значит для вашей команды на практике?

00:12:16.740 --> 00:12:18.800
Начнем с того, что привлекает всеобщее внимание.

00:12:19.040 --> 00:12:20.760
Откаты становятся тривиальной задачей.

00:12:20.920 --> 00:12:22.240
Вышло неудачное развертывание.

00:12:22.500 --> 00:12:25.100
Приложение начало выдавать ошибки, пользователи жалуются.

00:12:25.100 --> 00:12:28.500
Раньше вам пришлось бы в спешке искать последнюю известную рабочую конфигурацию,

00:12:28.680 --> 00:12:31.440
выполнять серию ручных команд и молиться, чтобы ничего не упустить.

00:12:31.620 --> 00:12:33.700
В GitOps вы просто отменяете GitCommit.

00:12:33.900 --> 00:12:34.400
Вот и все.

00:12:34.620 --> 00:12:35.320
Одна команда.

00:12:35.480 --> 00:12:37.960
Оператор видит отмену, подтягивает предыдущее состояние,

00:12:38.120 --> 00:12:40.140
и кластер возвращается к тому, что работало раньше.

00:12:40.380 --> 00:12:43.920
Больше не нужно подключаться по SSH, использовать кубик Телл и уж точно никакой паники.

00:12:44.100 --> 00:12:45.940
Журнал аудита формируется автоматически.

00:12:46.160 --> 00:12:48.240
Любое изменение в инфраструктуре — это commit.

00:12:48.440 --> 00:12:51.120
Вы знаете, кто его сделал, когда и что именно изменил.

00:12:51.120 --> 00:12:54.960
Больше не нужно гадать, правил ли кто-то деплей в 2 часа ночи, забыв об этом сообщить.

00:12:55.080 --> 00:12:57.660
История сохраняется, она неизменна и доступна для проверки.

00:12:58.040 --> 00:13:01.080
Самовосстановление — еще одна вещь, которая кажется магией, пока не увидишь ее в деле.

00:13:01.240 --> 00:13:03.560
Кто-то вручную меняет настройки развертывания в кластере.

00:13:03.760 --> 00:13:06.140
Возможно, младший инженер пытается что-то быстро исправить.

00:13:06.300 --> 00:13:09.620
Оператор обнаруживает отклонение при следующем цикле синхронизации и откатывает его.

00:13:09.780 --> 00:13:13.180
Кластер восстанавливается сам, и вы даже не узнаете об этом, если не проверите логи.

00:13:13.540 --> 00:13:15.640
Согласованность между средами становится автоматической.

00:13:15.640 --> 00:13:19.540
Dev, Test, Staging, Production — все они берут данные из одного репозитория Git.

00:13:19.660 --> 00:13:22.320
Разные ветки или папки, но единый источник истины.

00:13:22.500 --> 00:13:26.540
Забудьте об «У меня на машине работает», потому что ваш Staging давно отстал от продакшена.

00:13:26.780 --> 00:13:30.380
Безопасность выше, так как кластер сам забирает данные из Git, а не принимает их извне.

00:13:30.540 --> 00:13:33.700
Ваш CI-конвейер не хранит учетные данные для прямого доступа к продакшену.

00:13:33.800 --> 00:13:36.680
Если кто-то взломает конвейер, он не сможет получить доступ к кластеру.

00:13:36.880 --> 00:13:38.840
Оператор сам решает, что и когда применять.

00:13:38.960 --> 00:13:40.700
Принцип минимальных привилегий по дизайну.

00:13:40.700 --> 00:13:42.560
И этому есть подтверждение в виде данных.

00:13:42.760 --> 00:13:47.980
Согласно исследованию DRA, команды, внедрившие GitOps, сокращают количество ошибок при DeepLay на 25%,

00:13:47.980 --> 00:13:51.240
а среднее время восстановления составляет менее двух минут при правильной настройке.

00:13:51.360 --> 00:13:53.760
Это не теория, это реальные отчеты организаций.

00:13:53.920 --> 00:13:57.100
Есть еще преимущества в совместной работе, которые легко упустить из виду.

00:13:57.220 --> 00:14:02.940
Изменения инфраструктуры проходят через пулл-реквесты, код-ревью и автоматические тесты, точно так же, как и код приложений.

00:14:03.120 --> 00:14:05.820
Ваши команды Ops и Dev говорят на одном языке — Git.

00:14:05.960 --> 00:14:08.640
Никаких передач задач, никаких «разверни это за меня».

00:14:08.640 --> 00:14:13.480
Все работают одинаково, но все еще существуют распространенные заблуждения, которые стоит прояснить.

00:14:13.920 --> 00:14:15.620
Распространенные мифы и начало работы.

00:14:15.820 --> 00:14:17.960
Давайте начнем с развенчания мифов о GitOps.

00:14:18.160 --> 00:14:21.080
Во-первых, многие думают, что GitOps — только для Kubernetes.

00:14:21.300 --> 00:14:24.020
И да, в Kubernetes это работает лучше всего, спору нет.

00:14:24.160 --> 00:14:28.260
Kubernetes построен на декларативном состоянии и согласовании, поэтому он идеально подходит.

00:14:28.380 --> 00:14:32.360
Но вот в чем дело, эти принципы применимы везде, где есть декларативные конфигурации.

00:14:32.520 --> 00:14:35.480
Вы можете использовать GitOps, Terraform, Pulumi и даже Ansible.

00:14:35.480 --> 00:14:38.940
Просто храните эти конфигурации в Git и используйте конвейер для их применения.

00:14:39.100 --> 00:14:43.940
Функция самовосстановления сложнее вне Kubernetes, но принцип единого источника истины работает везде.

00:14:44.160 --> 00:14:47.920
Еще один миф, что для GitOps обязательно нужны Argo, CD или Flacos.

00:14:48.120 --> 00:14:54.800
Если вам нужна полная модель, развертывание на основе запросов, постоянная синхронизация и отслеживание отклонений, то да, вам нужен GitOps-оператор.

00:14:54.900 --> 00:14:56.060
Но можно начать гораздо проще.

00:14:56.260 --> 00:14:59.420
Поместите все манифесты в Git и используйте пул запроса для внесения изменений.

00:14:59.560 --> 00:15:02.600
Уже одно это дает вам большинство преимуществ в плане аудита и совместной работы.

00:15:02.600 --> 00:15:05.660
Оператор всегда можно добавить позже, когда вам потребуется автоматизация.

00:15:05.800 --> 00:15:09.080
И, наконец, существует миф, что GitOps полностью заменяет CI, CD.

00:15:09.240 --> 00:15:11.320
Это не так, он заменяет только часть CD.

00:15:11.520 --> 00:15:16.360
CI по-прежнему собирает код, запускает тесты, сканирует на уязвимости и отправляет образы контейнеров в реестр.

00:15:16.500 --> 00:15:18.180
В этом плане все остается по-прежнему.

00:15:18.400 --> 00:15:20.600
Меняется лишь способ развертывания этих образов.

00:15:20.740 --> 00:15:25.560
Вместо того, чтобы CI-конвейер отправлял их в кластер, GitOps-оператор сам извлекает обновленные манифесты из Git.

00:15:25.700 --> 00:15:28.680
Таким образом, CI и GitOps работают вместе, а не вместо друг друга.

00:15:28.680 --> 00:15:30.560
Начать работу на самом деле очень просто.

00:15:30.740 --> 00:15:33.920
Выберите небольшой кластер AKS и включите Flux через портал Azure.

00:15:34.060 --> 00:15:35.640
Это займет всего несколько кликов.

00:15:35.820 --> 00:15:41.400
Затем укажите репозиторий Git с простым VAML-файлом развертывания, дождитесь синхронизации и можно приступать.

00:15:41.520 --> 00:15:45.100
Попробуйте изменить значение VAML, закомните его и наблюдайте за обновлением кластера.

00:15:45.240 --> 00:15:46.920
Это и есть ваш первый GitOps-процесс.

00:15:47.120 --> 00:15:51.180
Далее можно добавлять окружение, изучать Customize, поскольку Flux активно его использует,

00:15:51.300 --> 00:15:54.540
и настроить автоматическое обновление образов через Renovate или Dependable.

00:15:54.680 --> 00:15:56.440
Вот что такое GitOps в двух словах.

00:15:56.440 --> 00:16:02.120
Он превращает вашу инфраструктуру в Git-репозиторий, делая все очлеживаемым, откатываемым и самовосстанавливающимся.

00:16:02.280 --> 00:16:06.340
Если вы управляете Kubernetes в Azure, попробуйте интеграцию GitOps в AKS уже сегодня.

00:16:06.560 --> 00:16:09.560
Настройка займет 10 минут и изменит ваш взгляд на развертывание.

00:16:09.720 --> 00:16:13.300
Подписывайтесь, чтобы видеть больше простых объяснений облачных инструментов Microsoft.
