WEBVTT

00:00:00.280 --> 00:00:04.720
Сьогоднішня тема – це те, про що майже всі чули, але мало хто може насправді пояснити.

00:00:05.000 --> 00:00:09.660
GTOPS. Ви, мабуть, бачили цю згадку у вакансіях, на конференціях чи в документації Azure.

00:00:09.860 --> 00:00:14.740
Але що це таке насправді? Це просто черговий модний термін DevOps чи щось кардинально інше?

00:00:14.880 --> 00:00:16.060
Ось коротка відповідь.

00:00:16.220 --> 00:00:20.920
GTOPS – це робоча модель, де дід стає єдиним джерелом істини для всієї вашої інфраструктури,

00:00:21.040 --> 00:00:24.160
не лише коду додатків, а й усього, що забезпечує їхню роботу.

00:00:24.160 --> 00:00:30.020
Наприкінці цього епізоду ви зрозумієте, що таке GTOPS, чому він став стандартом для керування Кубанітас-Вежур

00:00:30.020 --> 00:00:32.820
і як він дозволяє робити відкати однією командою.

00:00:33.260 --> 00:00:36.420
Старий підхід – ручне розгортання та розбіжність конфігурацій.

00:00:36.540 --> 00:00:38.600
Почнімо з проблеми, яку вирішує GTOPS.

00:00:38.760 --> 00:00:41.300
Уявіть, що ви керуєте кластером Кубанітас-Вежур.

00:00:41.440 --> 00:00:47.600
Розробники надсилають код «CI-конвейер будує образи контейнерів, а хтось запускає кубикателл-аплай для їх розгортання».

00:00:47.600 --> 00:00:52.380
Можливо, ви, можливо, колега, або ви натискаєте кнопку в Azure DevOps, і так чи інакше розгортання відбувається.

00:00:52.520 --> 00:00:54.580
Це працює добре, поки не виникають проблеми.

00:00:54.700 --> 00:00:55.980
Ось що відбувається далі.

00:00:56.100 --> 00:00:59.780
Комусь із вашої команди потрібно швидко виправити помилку, тому він підключається по SSH до вузла,

00:00:59.900 --> 00:01:03.080
використовує портал Azure або запускає кубикател-едит безпосередньо для розгортання.

00:01:03.240 --> 00:01:08.220
Вони вносять невелику зміну, наприклад, правлять конфіг-меп або змінюють змінну середовища, і це здається безпечним.

00:01:08.480 --> 00:01:09.800
Принаймні, вони так думають.

00:01:09.800 --> 00:01:15.840
Проблема в тому, що ця зміна не потрапляє в діт, тому ваш кластер тепер має конфігурацію, яка не відповідає тому, що у вашому репозиторії.

00:01:16.000 --> 00:01:18.540
Це називається «розбіжність конфігурацій» або «дріфт».

00:01:18.540 --> 00:01:25.380
Розбіжність – це тихий вбивця, бо все працює до наступного розгортання, коли хтось запускає кубикател-аплай з оригінальним маніфестом і перезаписує це швидке виправлення.

00:01:25.500 --> 00:01:29.140
Або гірше – розбіжність викликає неочікувану поведінку, яку ніхто не може пояснити.

00:01:29.140 --> 00:01:34.540
Ви починаєте налагодження, перевіряєте логи, дивитесь на VAML, у діт, усе здається правильним, але кластер поводиться інакше.

00:01:34.680 --> 00:01:39.080
Ви не маєте уявлення, що змінилося, коли і хто це зробив. Я бачив, як це трапляється.

00:01:39.240 --> 00:01:44.500
Колега підключається по SSH до вузла, змінює конфігурацію для тесту, забуває повернути все назад і йде додому.

00:01:44.720 --> 00:01:47.940
Наступного дня розгортання ламається, і ніхто не може пояснити, чому.

00:01:47.940 --> 00:01:53.300
Репозиторій діт виглядає чистим, але в кластері хаос, і ви витрачаєте години, намагаючись з'ясувати, що сталося.

00:01:53.420 --> 00:01:58.260
Тож виникає питання. Що, якби існував спосіб змусити кластер завжди відповідати тому, що є в діт?

00:01:58.360 --> 00:02:02.720
Що, якби можна було гарантувати, що те, що знаходиться у вашому репозиторії, є саме тим, що працює у виробничому середовищі?

00:02:02.840 --> 00:02:06.120
Це і є головна ідея GTOPS. Що таке GTOPS насправді?

00:02:06.240 --> 00:02:10.120
Отже, що саме таке GTOPS? Ось найпростіше визначення, яке я можу дати.

00:02:10.120 --> 00:02:15.320
Діт стає вашим єдиним джерелом істини не лише для коду, а й для всього, що потрібно вашій інфраструктурі для роботи.

00:02:15.440 --> 00:02:20.100
Кожна конфігурація, кожен маніфест розгортання, кожна змінна середовища – усе це зберігається в діт.

00:02:20.260 --> 00:02:22.980
Ніщо не запускається у вашому кластері, якщо воно не визначено там.

00:02:23.180 --> 00:02:27.120
GTOPS – це не інструмент, який можна купити. Це операційна модель, як DevOps або DevSecOps.

00:02:27.860 --> 00:02:30.960
Набір принципів, що керують тим, як ви керуєте своєю інфраструктурою.

00:02:30.960 --> 00:02:35.080
Стандарт OpenDTops визначає чотири основні принципи, і я хочу пройтися по кожному з них.

00:02:35.220 --> 00:02:37.420
По-перше, ваша система має бути декларативною.

00:02:37.560 --> 00:02:40.820
Це означає, що ви описуєте кінцевий стан, а не кроки для його досягнення.

00:02:40.980 --> 00:02:45.360
Замість написання сценарію, створити розгортання, масштабувати до п'яти реплік, відкрити порт 8080,

00:02:45.580 --> 00:02:50.600
ви пишете в IAML-файл, у якому вказуєте «хочу п'ять реплік на порту 8080», а система сама визначає кроки.

00:02:50.740 --> 00:02:52.060
І це декларативний підхід.

00:02:52.060 --> 00:02:53.900
По-друге, він має бути версіонованим.

00:02:53.900 --> 00:02:56.580
Будь-яка зміна, яку ви вносите у стан свого кластера, є комітом у дід.

00:02:56.700 --> 00:02:59.300
Отже, ви отримуєте повну історію «хто, що, коли і чому змінив».

00:02:59.300 --> 00:03:01.120
Більше ніяких здогадок чи перегляду логів.

00:03:01.240 --> 00:03:03.100
По-третє, зміни витягуються автоматично.

00:03:03.260 --> 00:03:05.420
Кластер звертається до дід, щоб побачити щонового.

00:03:05.560 --> 00:03:07.340
Пізніше я поясню, чому це так важливо.

00:03:07.500 --> 00:03:09.640
І по-четверте, система постійно узгоджується.

00:03:09.800 --> 00:03:14.300
Усередині вашого кластера працює програмний агент, який постійно порівнює те, що в дід, із тим, що запущено насправді.

00:03:14.300 --> 00:03:16.540
Якщо вони не збігаються, він усуває розбіжність.

00:03:16.660 --> 00:03:18.000
Це і є цикл узгодження.

00:03:18.200 --> 00:03:19.220
Подумайте про це так.

00:03:19.380 --> 00:03:20.920
Дід – це креслення архітектора.

00:03:21.100 --> 00:03:23.440
У ньому точно описано, як має виглядати будівля.

00:03:23.840 --> 00:03:25.480
Кубанітаз – це будівельний майданчик.

00:03:25.580 --> 00:03:27.320
А G-Tops-оператор – це виконроб.

00:03:27.460 --> 00:03:30.820
Він ходить із кресленням, перевіряючи кожну стіну, кожну балку, кожне вікно.

00:03:30.980 --> 00:03:33.020
Якщо щось не збігається, він це виправляє.

00:03:33.180 --> 00:03:37.060
Якщо хтось із команди вносить несанкціоновану зміну, він помічає це і скасовує її.

00:03:37.060 --> 00:03:39.120
Креслення завжди є джерелом істини.

00:03:39.260 --> 00:03:41.040
Але саме тут відбувається справжній су.

00:03:41.220 --> 00:03:42.840
Як насправді працюють розгортання.

00:03:43.000 --> 00:03:45.880
У традиційному CI-CD ви проштовхуєте зміни в кластер.

00:03:46.000 --> 00:03:49.540
У G-Tops-кластер витягує їх, і ця різниця важливіша, ніж здається.

00:03:49.720 --> 00:03:52.420
Розгортання на основі витягування проти проштовхування.

00:03:52.580 --> 00:03:56.340
Поговорімо про те, як розгортання працюють насправді, бо саме тут G-Tops змінює все.

00:03:56.520 --> 00:03:59.920
У традиційній моделі проштовхування ваш CI-конвейер робить усе.

00:04:00.060 --> 00:04:02.720
Azure Pipelines Jenkins GitHub Actions.

00:04:02.720 --> 00:04:08.180
Він збирає контейнер, виконує тести, а потім відправляє образ безпосередньо у ваш Кубанітас-кластер.

00:04:08.300 --> 00:04:11.880
Конвейер містить облікові дані, які надають йому прямий доступ до ARRI-кластера.

00:04:12.080 --> 00:04:13.840
Він каже, ось нове розгортання.

00:04:14.060 --> 00:04:15.200
Застосуй його зараз.

00:04:15.300 --> 00:04:17.700
Це працює, але створює проблему з безпекою.

00:04:17.860 --> 00:04:19.720
Річ у тім, що якщо цей конвейер буде скомпрометовано,

00:04:20.520 --> 00:04:24.200
хтось впровадить шкідливий крок, витече токен або буде перехоплено залежність,

00:04:24.300 --> 00:04:26.980
цей конвейер матиме прямий вихід на ваш робочий кластер.

00:04:26.980 --> 00:04:30.400
Він може знищити розгортання, видалити простори імен, змінити конфігурації,

00:04:30.500 --> 00:04:33.100
і все це завдяки дозволам, які ви надали йому для виконання роботи.

00:04:33.180 --> 00:04:34.700
Тепер подивіться на модель GTOPS.

00:04:34.840 --> 00:04:36.160
Потік починається так само.

00:04:36.340 --> 00:04:39.240
CI збирає контейнер і відправляє його в реєстр, наприклад, Azure Container Registry.

00:04:39.400 --> 00:04:40.700
На цьому CI зупиняється.

00:04:40.880 --> 00:04:42.080
Він не торкається кластера.

00:04:42.260 --> 00:04:45.640
Натомість CI оновлює Git-репозиторій за допомогою нового тего-образу.

00:04:45.780 --> 00:04:49.680
Він змінює один рядок у VAML-файлі, версію образу, і фіксує цю зміну.

00:04:49.680 --> 00:04:52.140
Це все. Жодного прямого доступу до кластера.

00:04:52.280 --> 00:04:55.420
Потім оператор GTOPS, що працює всередині вашого кластера, бачить цю зміну.

00:04:55.560 --> 00:04:58.080
Він витягує останній стан із Git і застосовує його.

00:04:58.240 --> 00:05:00.320
Кластер звертається до Git, а не навпаки.

00:05:00.520 --> 00:05:01.380
Це пул-модель.

00:05:01.580 --> 00:05:04.340
Ваш кластер ніколи не відкриває свій ARRI зовнішнім системам.

00:05:04.480 --> 00:05:05.800
Він лише витягує дані з Git.

00:05:05.960 --> 00:05:08.440
Якщо хтось скомпрометує ваш CI-конвайер, максимум, що вони зможуть зробити,

00:05:08.520 --> 00:05:09.620
це змінити маніфест у репозиторії.

00:05:09.760 --> 00:05:11.560
Вони не можуть торкнутися кластера безпосередньо.

00:05:11.560 --> 00:05:13.480
Оператор вирішує, що і коли застосувати.

00:05:13.640 --> 00:05:14.740
Є ще одна перевага.

00:05:14.860 --> 00:05:16.560
Ви відокремлюєте збирання від розгортання.

00:05:16.720 --> 00:05:19.240
CI робить те, у чому він гарний – збирання, тестування, сканування.

00:05:19.400 --> 00:05:21.160
Оператор GTOPS займається розгортанням.

00:05:21.260 --> 00:05:22.980
Кожна система зосереджена на одній роботі.

00:05:23.120 --> 00:05:25.180
Якщо збирання не вдається, у кластері нічого не змінюється.

00:05:25.340 --> 00:05:27.980
Якщо розгортання не вдається, оператор робить повторну спробу або сповіщає вас.

00:05:28.100 --> 00:05:29.020
Чисте розділення.

00:05:29.020 --> 00:05:31.800
Отже, замість того, щоб конвайер штовхав зміни у ваш кластер,

00:05:31.800 --> 00:05:33.780
ваш кластер сам витягує бажаний стан із дід.

00:05:33.900 --> 00:05:36.900
Ця проста інверсія робить вашу інфраструктуру безпечнішою,

00:05:37.060 --> 00:05:39.780
контрольованішою та менш вразливою до випадкових поломок.

00:05:40.280 --> 00:05:41.440
Цикл узгодження.

00:05:41.600 --> 00:05:44.120
Отже, як оператор дізнається, коли оновлюватися.

00:05:44.360 --> 00:05:45.720
Він не чекає на сповіщення.

00:05:45.920 --> 00:05:47.940
Він запускає безперервний цикл, стежить за дід,

00:05:48.040 --> 00:05:50.140
порівнює з кластером, застосовує зміни за потреби,

00:05:50.140 --> 00:05:51.920
а потім робить це знову і знову нескінченно.

00:05:52.060 --> 00:05:53.780
Це називається циклом узгодження.

00:05:53.780 --> 00:05:56.120
Він працює постійно, кожні кілька секунд або хвилин,

00:05:56.220 --> 00:05:57.500
залежно від вашої конфігурації.

00:05:57.680 --> 00:05:59.540
Оператор ніколи не припиняє спостереження.

00:05:59.700 --> 00:06:01.520
Уявіть це як термостат у вашому домі.

00:06:01.600 --> 00:06:04.320
Ви встановлюєте бажану температуру, скажімо, 21 градус.

00:06:04.420 --> 00:06:06.600
Термостат постійно перевіряє фактичну температуру.

00:06:06.760 --> 00:06:09.100
Якщо вона опускається нижче 21, вмикається опалення.

00:06:09.260 --> 00:06:11.040
Якщо піднімається вище, опалення вимикається.

00:06:11.040 --> 00:06:13.400
Він постійно регулює роботу, щоб відповідати вашим налаштуванням.

00:06:13.500 --> 00:06:15.180
GTOPS оператор працює так само.

00:06:15.180 --> 00:06:17.740
DIT містить бажаний стан, кластер має фактичний стан,

00:06:17.820 --> 00:06:20.160
а оператор постійно порівнює їх і вносить корективи.

00:06:20.280 --> 00:06:23.320
Отже, що відбувається, коли хтось вручну редагує розгортання в кластері?

00:06:23.440 --> 00:06:26.380
Можливо, вони запускають кубик ато Edit, щоб змінити кількість реплік.

00:06:26.520 --> 00:06:29.540
Оператор виявляє цю різницю під час наступного циклу узгодження.

00:06:29.700 --> 00:06:32.220
У кластері тепер три репліки, але в DIT вказано п'ять.

00:06:32.220 --> 00:06:35.940
Тож оператор застосовує стан, визначений у DIT, і кластер повертається до п'яти реплік.

00:06:35.940 --> 00:06:37.540
Несанкціонувану зміну скасовано.

00:06:37.700 --> 00:06:39.580
Що відбувається, коли ви нацилаєте зміни до DIT?

00:06:39.680 --> 00:06:40.640
Той самий процес.

00:06:40.780 --> 00:06:42.980
Оператор виявляє різницю і застосовує її.

00:06:43.140 --> 00:06:47.420
Розробник зливає піар, який оновлює версію образу з V1.2 до V1.3.

00:06:47.580 --> 00:06:51.720
Оператор бачить новий маніфест, завантажує новий образ і запускає нові поди.

00:06:51.720 --> 00:06:54.400
Залічені секунди кластер знову відповідає DIT.

00:06:54.520 --> 00:06:56.000
Тут є важлива відмінність.

00:06:56.160 --> 00:06:58.560
Якщо подаваріно завершується, оператору байдуже.

00:06:58.560 --> 00:07:01.480
Це завдання Кубанітаз, яке виконує контролер реплікасет.

00:07:01.660 --> 00:07:04.160
DITOPS оператора цікавить лише конфігурація.

00:07:04.340 --> 00:07:07.900
Якщо маніфест розгортання вимагає п'ять реплік і образ V1.3,

00:07:08.040 --> 00:07:11.580
а в кластері працюють п'ять реплік V1.3, оператор задоволений.

00:07:11.820 --> 00:07:14.280
Його не хвилює чи перезавантажився конкретний под.

00:07:14.280 --> 00:07:16.140
Це звичайна поведінка Кубанітаз.

00:07:16.260 --> 00:07:19.080
Але якщо хтось змінює маніфест у DIT або безпосередньо в кластері,

00:07:19.180 --> 00:07:20.840
створюючи розбіжність, оператор діє.

00:07:20.840 --> 00:07:22.960
Саме це робить DITOPS самовідновлюваним.

00:07:23.140 --> 00:07:25.660
Він не просто розгортає зміни, він активно запобігає відхиленню

00:07:25.660 --> 00:07:27.460
вашої інфраструктури від визначеного стану.

00:07:27.580 --> 00:07:30.400
Отже, вам потрібен DITOPS оператор, що працює у вашому кластері.

00:07:30.500 --> 00:07:32.820
Ось тут на допомогу приходять AGO-CD та FLAX.

00:07:32.940 --> 00:07:34.400
AGO-CD проти FLAX.

00:07:34.400 --> 00:07:39.120
Отже, вам потрібен DITOPS оператор, і у вас є два основні варіанти, обидва чудові.

00:07:39.220 --> 00:07:41.700
AGO-CD та FLAX – це проєкти рівня CNCF,

00:07:41.820 --> 00:07:44.600
що означає, що вони пройшли найвищі критерії стабільності,

00:07:44.600 --> 00:07:46.220
спільноти та готовності до роботи.

00:07:46.320 --> 00:07:49.280
Але вони підходять до одного і того самого завдання з різних боків.

00:07:49.400 --> 00:07:52.740
AGO-CD був спочатку створений Intuit і постачається з веб-інтерфейсом.

00:07:52.880 --> 00:07:55.540
Коли ви встановлюєте AGO-CD, ви отримуєте панель керування,

00:07:55.660 --> 00:07:58.220
де можна бачити кожну програму, її статус синхронізації,

00:07:58.220 --> 00:07:59.580
стан та історії розгортання.

00:07:59.740 --> 00:08:02.220
Ви можете переглядати відмінності між DIT і кластером,

00:08:02.360 --> 00:08:04.560
вручну запускати процеси та схвалювати зміни.

00:08:04.720 --> 00:08:07.480
Він розроблений для команд, яким потрібні візуальні панелі керування

00:08:07.480 --> 00:08:08.600
та ручні точки контролю.

00:08:14.600 --> 00:08:16.860
Ви визначаєте все як спеціальні ресурси Кубанітаз.

00:08:17.000 --> 00:08:20.400
Ви створюєте об'єкт DIT-репозиторію, який каже «Стеж за цим репозиторієм».

00:08:20.400 --> 00:08:23.240
І об'єкт налаштування, який каже «Застосувати цей шлях».

00:08:23.240 --> 00:08:25.280
Flux підхоплює його та виконує узгодження.

00:08:25.420 --> 00:08:27.320
Це змушує вас прийняти DIT-орієнтовані робочі процеси,

00:08:27.320 --> 00:08:29.280
оскільки немає панелі керування, на яку можна покластися.

00:08:29.380 --> 00:08:31.360
Тепер про те, що важливо для користувачів Azure.

00:08:31.500 --> 00:08:34.540
Flux є стандартною опцією DITOPS у службі Azure Кубанітаз Service.

00:08:34.540 --> 00:08:37.440
Microsoft побудувала нативну інтеграцію навколо Flux V2.

00:08:37.600 --> 00:08:40.200
Коли ви вмикаєте DITOPS у кластері AKS через портал Azure,

00:08:40.300 --> 00:08:42.080
ви використовуєте Flux у фоновому режимі.

00:08:42.200 --> 00:08:45.020
Azure Arc також використовує Flux для керування кількома кластерами.

00:08:45.120 --> 00:08:47.860
Тож, якщо ви інженер Azure, Flux – це природна відправна точка.

00:08:47.860 --> 00:08:50.000
Але Ago CD має свої сильні сторони.

00:08:50.100 --> 00:08:52.280
Він популярніший для сценаріїв платформної інженерії,

00:08:52.380 --> 00:08:54.620
де потрібна центральна панель керування для кількох кластерів.

00:08:54.740 --> 00:08:58.280
Інтерфейс спрощує роботу командам, яким незручно користуватися командним рядком.

00:08:58.280 --> 00:09:01.300
І він тісно інтегрується з Ago Rollouts для поступової доставки,

00:09:01.440 --> 00:09:03.920
як от Canary розгортання, Blue Green розгортання тощо.

00:09:04.100 --> 00:09:06.400
Ключова архітектурна відмінність полягає в наступному.

00:09:06.540 --> 00:09:09.580
Ago CD працює як окремий додаток із власним ARRI сервером.

00:09:09.580 --> 00:09:13.920
Flux працює як набір контролерів Kubernetes, глибше вбудованих у сам кластер.

00:09:14.040 --> 00:09:16.980
Flux сприймається як частина вашої панелі керування Kubernetes,

00:09:17.140 --> 00:09:19.740
тоді як Ago CD, як окрема платформа поверх неї.

00:09:19.900 --> 00:09:21.880
Flux також значною мірою покладається на Customize,

00:09:22.020 --> 00:09:24.060
який є нативним інструментом шаблонізації Kubernetes.

00:09:24.060 --> 00:09:27.420
Ago CD може використовувати Customize, Helm або звичайні файли via YML.

00:09:27.600 --> 00:09:30.220
Обидва підтримують Helm, але у Flux є спеціальний контролер Helm,

00:09:30.360 --> 00:09:31.780
який обробляє релізи Helm нативно.

00:09:31.900 --> 00:09:33.300
Тут немає неправильного вибору.

00:09:33.460 --> 00:09:35.440
Обидва інструменти виконують одну й ту саму роботу.

00:09:35.440 --> 00:09:38.220
Але для інженерів Azure Flux це шлях найменшого спротиву.

00:09:38.320 --> 00:09:41.400
Ви можете ввімкнути D-Tops за допомогою Flux у кілька кліків через портал Azure,

00:09:41.560 --> 00:09:43.840
вказати на D-трепозиторі і він почне синхронізацію.

00:09:43.840 --> 00:09:47.140
Жодних додаткових інсталяцій, жодного окремого сервера для керування.

00:09:47.360 --> 00:09:50.200
D-Tops на Azure AKS, Azure Act та Azure DevOps.

00:09:50.420 --> 00:09:53.440
Отже, як це насправді виглядає, коли ви об'єднуєте все це в Azure?

00:09:53.600 --> 00:09:54.700
Почнемо з AKS.

00:09:54.820 --> 00:09:58.740
Azure Kubernetes Service має вбудовану підтримку D-Tops із використанням Flux V2.

00:09:58.900 --> 00:10:01.200
На порталі Azure ви переходите до свого кластера,

00:10:01.360 --> 00:10:05.200
знаходите розділ D-Tops і налаштовуєте його, вказуючи на D-трепозиторі.

00:10:05.340 --> 00:10:07.200
Azure Repose, GitHub, будь-де.

00:10:07.200 --> 00:10:10.620
Flux починає стежити, і будь-які маніфести, які ви додаєте до цього репозиторію,

00:10:10.700 --> 00:10:12.460
автоматично застосовуються до вашого кластера.

00:10:12.600 --> 00:10:14.460
Але AKS – це лише одна частина.

00:10:14.600 --> 00:10:16.660
Azure AKS розширює можливості D-Tops на кластери,

00:10:16.780 --> 00:10:19.700
які не знаходяться в Azure, локальні, в інших хмарах або на периферії.

00:10:19.840 --> 00:10:23.700
Підключіть їх до Azure AKS, і ви зможете керувати ними всіма за допомогою однієї конфігурації D-Tops.

00:10:23.860 --> 00:10:26.340
Один репозиторій, багато кластерів, узгоджений стан усюди.

00:10:26.480 --> 00:10:27.440
Ось що робить AKS.

00:10:27.440 --> 00:10:29.300
Тепер поговоримо про конвейер, пайплайн.

00:10:37.200 --> 00:10:43.200
Він створює образ контейнера, запускає тести, сканує на вразливості та надсилає образ до Azure Container Registry.

00:10:43.360 --> 00:10:45.960
Потім конвейер оновлює маніфести у вашому D-Tops репозиторії,

00:10:46.080 --> 00:10:49.920
змінюючи тех-образу з V1.2 на V1.3, фіксує цю зміну та відправляє її.

00:10:50.080 --> 00:10:50.540
Це все.

00:10:50.740 --> 00:10:53.160
Конвейер ніколи не звертається до кластера безпосередньо.

00:10:53.260 --> 00:10:56.940
Flux, що працює всередині AKS, виявляє зміни в D-T, завантажує новий маніфест,

00:10:56.940 --> 00:10:59.240
бачить оновлений тех-образу та застосовує розгортання.

00:10:59.240 --> 00:11:01.700
Запускаються нові поди, і кластер синхронізується.

00:11:01.860 --> 00:11:05.100
Ви можете використовувати GitHub Actions замість Azure Pipelines, якщо бажаєте.

00:11:05.240 --> 00:11:06.860
Шаблон залишається таким самим.

00:11:07.000 --> 00:11:11.240
CI займається збіркою та оновленням маніфестів, а D-Tops оператор відповідає за розгортання.

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

00:11:13.840 --> 00:11:14.840
Ось важлива деталь.

00:11:14.980 --> 00:11:19.720
Ніколи не зберігайте секрети безпосередньо в DIT, ні ключі ARRI, ні рядки підключення, ні сертифікати.

00:11:19.720 --> 00:11:22.540
Навіть у приватному репозиторії секрети в DIT це ризи.

00:11:22.540 --> 00:11:26.060
Замість цього використовуйте Azure Key Vault або зовнішній оператор секретів.

00:11:26.220 --> 00:11:31.320
Маніфест посилається на секрет за іменем, а оператор отримує фактичне значення зі сховища під час розгортання.

00:11:31.520 --> 00:11:33.560
Ви також можете накласти політику зверху.

00:11:33.720 --> 00:11:40.200
Azure Policy разом із Gatekeeper може встановлювати правила, наприклад, заборону привілейованих контейнерів або використання лише дозволених реєстрів.

00:11:40.200 --> 00:11:45.620
Якщо хтось спробує розгорнути маніфест, що порушує політику, Gatekeeper заблокує його до потрапляння в кластер.

00:11:45.740 --> 00:11:47.660
Реальна перевага тут – це масштабування.

00:11:47.660 --> 00:11:51.300
Маючи 50 кластерів AKS, ви не керуєте кожним окремо.

00:11:51.460 --> 00:11:56.600
Визначаєте бажаний стан в одному DIT-репозиторії, і кожен кластер підлаштовується під цей стан.

00:11:56.800 --> 00:12:00.320
Додайте новий кластер, вкажіть на репозиторій, і він налаштується сам.

00:12:00.460 --> 00:12:03.000
Потрібно оновити конфігурацію в усіх кластерах.

00:12:03.160 --> 00:12:06.060
Змініть один файл у DIT, і оператори зроблять усе інше.

00:12:06.220 --> 00:12:08.340
Це і є головна перевага DITOPS в Azure.

00:12:08.520 --> 00:12:11.600
Одне джерело істини – багато кластерів, жодних відхилень.

00:12:11.740 --> 00:12:12.860
Ключові переваги.

00:12:12.860 --> 00:12:16.560
Отже, усе це звучить добре в теорії, але що це насправді означає для вашої команди?

00:12:16.640 --> 00:12:18.980
Почнемо з того, що привертає найбільшу увагу.

00:12:19.120 --> 00:12:20.640
Відкати стають тривіальними.

00:12:20.780 --> 00:12:24.740
Погане розгортання здійснено, програма видає помилки, користувачі скаржаться.

00:12:24.940 --> 00:12:28.140
Раніше вам довелося б поспіхом шукати останню відому робочу конфігурацію,

00:12:28.260 --> 00:12:31.240
виконувати купу ручних команд і молитися, щоб нічого не пропустити.

00:12:31.420 --> 00:12:33.620
У DITOPS ви просто скасуєте git commit.

00:12:33.840 --> 00:12:35.420
Це все. Одна команда.

00:12:35.580 --> 00:12:38.000
Оператор бачить скасування, завантажує попередній стан,

00:12:38.000 --> 00:12:40.300
і кластер повертається до того, що працювало раніше.

00:12:40.460 --> 00:12:43.680
Жодних SSH, жодних кубикатл і, безумовно, жодної паніки.

00:12:44.000 --> 00:12:45.900
Аудиторський слід вбудовано автоматично.

00:12:46.080 --> 00:12:48.320
Кожна зміна вашої інфраструктури – це коміт.

00:12:48.500 --> 00:12:50.980
Ви знаєте, хто це зробив, коли і що саме змінив.

00:12:51.120 --> 00:12:54.980
Більше ніяких здогадок, чи редагував хтось розгортання о другій ночі і забув про це сказати.

00:12:55.160 --> 00:12:57.560
Історія наявна, незмінна та доступна для перегляду.

00:12:57.820 --> 00:13:01.100
Самолікування – ще одна річ, яка звучить як магія, доки не побачиш її в дії.

00:13:01.100 --> 00:13:03.360
Хтось вручну редагує розгортання в кластері.

00:13:03.500 --> 00:13:06.080
Можливо, молодший інженер намагається швидко щось виправити.

00:13:06.240 --> 00:13:09.500
Оператор виявляє відхилення під час наступного циклу узгодження та скасовує його.

00:13:09.680 --> 00:13:13.160
Кластер лікує себе сам, і ви навіть не знаєте, що це сталося, поки не перевірити логи.

00:13:13.360 --> 00:13:15.100
Узгодженість між середовищами стає автоматичною.

00:13:15.860 --> 00:13:19.460
Dev, Test, Staging, Production – усі вони беруть дані з одного діт-репозиторію.

00:13:19.620 --> 00:13:22.060
Різні гілки чи папки, але єдине джерело істини.

00:13:22.060 --> 00:13:26.520
Більше ніяких на моїй машині працює, бо ваш тестовий кластер тижні тому відхилився від продуктового.

00:13:26.680 --> 00:13:30.200
Безпека покращується, оскільки кластер забирає дані з діт, а не їх штовхають у нього.

00:13:30.360 --> 00:13:33.700
Ваш CI-конвейер ніколи не зберігає облікові дані для прямого доступу до продуктового середовища.

00:13:33.840 --> 00:13:36.600
Якщо хтось скомпрометує конвейер, він не зможе отримати доступ до кластера.

00:13:36.760 --> 00:13:38.820
Оператор сам вирішує, що і коли застосовувати.

00:13:39.000 --> 00:13:40.740
Принцип мінімальних привілеїв за дизайном.

00:13:40.880 --> 00:13:42.420
Це також підтверджується даними.

00:13:42.420 --> 00:13:47.960
Згідно з дослідженнями D.O.R.A., команди, що використовують GTOPS, бачать зменшення помилок розгортання на 25%,

00:13:47.960 --> 00:13:51.460
а середній час відновлення скорочується до 2 хвилин у добре налаштованих системах.

00:13:51.560 --> 00:13:53.880
Це не теорія, це звіти організацій.

00:13:54.000 --> 00:13:56.700
І є перевага в співпраці, яку легко не помітити.

00:13:56.900 --> 00:14:02.600
Зміни в інфраструктурі проходять через пул запити, рев'ю коду та автоматизовані тести, так само, як і код додатків.

00:14:02.760 --> 00:14:05.800
Ваші команди розробки та операції розмовляють однією мовою – діт.

00:14:05.800 --> 00:14:08.580
Жодних передач завдань, жодних – просто розгорний – це для мене.

00:14:08.660 --> 00:14:09.980
Усі працюють однаково.

00:14:10.100 --> 00:14:13.360
Але залишаються певні поширені непорозуміння, які варто прояснити.

00:14:13.540 --> 00:14:15.400
Поширені міфи та початок роботи.

00:14:15.520 --> 00:14:18.160
Почнімо з розвінчання кількох поширених міфів про GTOPS.

00:14:18.280 --> 00:14:21.120
По-перше, багато хто вважає, що GTOPS тільки для Кубанітаз.

00:14:21.240 --> 00:14:24.040
Звісно, на Кубанітаз він працює найкраще, тут немає питань.

00:14:24.160 --> 00:14:28.140
Кубанітаз побудований навколо декларативного стану та узгодження, тому це природний вибір.

00:14:28.140 --> 00:14:29.040
Але ось у чому річ.

00:14:29.160 --> 00:14:32.260
Ці самі принципи застосовні всюди, де є декларативні конфігурації.

00:14:32.460 --> 00:14:35.480
Ви можете використовувати GTOPS, стерафом, пулумі чи навіть ансібл.

00:14:35.600 --> 00:14:38.940
Просто зберігайте ці конфігурації в діт і дозвольте конвоєру застосовувати їх.

00:14:39.100 --> 00:14:43.680
Функція самолікування складніша поза Кубанітаз, але дисципліна єдиного джерела істини працює всюди.

00:14:43.860 --> 00:14:48.060
Інший міф полягає в тому, що для використання GTOPS обов'язково потрібні AGO-CD або FLAX.

00:14:48.060 --> 00:14:54.680
Якщо ви прагнете повної моделі, розгортання на основі витягування, пул, постійного узгодження та виявлення розбіжностей, то так, вам потрібен певний GTOPS оператор.

00:14:54.800 --> 00:14:59.600
Але почати можна простіше. Просто розмістіть усі свої маніфести в діт і використовуйте запити на злиття, пул реквестс для внесення змін.

00:14:59.740 --> 00:15:02.400
Вже це надасть вам більшість переваг аудиту та спільної роботи.

00:15:02.540 --> 00:15:05.700
Ви завжди зможете додати оператор пізніше, коли виникне потреба в автоматизації.

00:15:05.840 --> 00:15:08.860
І нарешті існує міф, що GTOPS повністю замінює CI-CD.

00:15:08.860 --> 00:15:11.400
Це не так. Він замінює лише частину CD.

00:15:11.600 --> 00:15:16.400
CI все ще збирає ваш код, запускає тести, сканує на вразливості та відправляє образи контейнерів у реєстр.

00:15:16.520 --> 00:15:20.560
Це все залишається незмінним. Змінюється лише спосіб розгортання цих образів.

00:15:20.740 --> 00:15:25.540
Замість того, щоб CI-конвейер проштовхував їх у кластер, GTOPS оператор витягує оновлені маніфести з діт.

00:15:25.700 --> 00:15:28.480
Отже, CI та GTOPS працюють разом, а не замість одне одного.

00:15:28.700 --> 00:15:30.520
Розпочати роботу насправді досить просто.

00:15:30.700 --> 00:15:33.840
Оберіть невеликий AKS-кластер і увімкніть FLAX через портал Azure.

00:15:33.840 --> 00:15:35.540
Це займає лише кілька кліків.

00:15:35.660 --> 00:15:41.420
Потім спрямуйте його на DIT-репозиторі, що містить простий VAML-файл розгортання, спостерігайте за синхронізацією і готово.

00:15:41.540 --> 00:15:45.160
Спробуйте змінити значення в VAML, зафіксуйте, коміт, зміни і подивіться, як оновиться кластер.

00:15:45.280 --> 00:15:46.720
Це ваш перший GTOPS-процес.

00:15:46.900 --> 00:15:50.540
Згодом ви зможете додавати середовище, вивчити Customize, оскільки FLAX активно його використовує,

00:15:50.620 --> 00:15:54.480
і налаштувати автоматичні оновлення образів за допомогою таких інструментів, як Renovate або Dependabot.

00:15:54.480 --> 00:15:56.360
Отже, GTOPS у двох словах – це все.

00:15:56.540 --> 00:16:02.260
Він перетворює вашу інфраструктуру на DIT-репозиторі, роблячи все відстежуваним, таким, що підлягає скасуванню, та здатним до самовідновлення.

00:16:02.380 --> 00:16:06.260
Якщо ви керуєте Кубані та Звежур, спробуйте GTOPS-інтеграцію в IKS вже сьогодні.

00:16:06.500 --> 00:16:09.620
Налаштування займає 10 хвилин і змінить ваше ставлення до розгортань.

00:16:09.620 --> 00:16:13.260
Підписуйтесь, щоб отримувати більше простих пояснень хмарних інструментів Microsoft.
