WEBVTT

00:00:00.000 --> 00:00:05.060
Вам нужна тестовая среда в Азур. Ничего сложного, просто виртуальная сеть, пара виртуальных машин и

00:00:05.060 --> 00:00:09.720
учетная запись хранения. Итак, вы входите на портал, находите кнопку группы ресурсов и начинаете

00:00:09.720 --> 00:00:14.340
кликать. Один клик для создания группы, еще несколько для настройки виртуальной сети, затем вы

00:00:14.340 --> 00:00:19.600
проходите мастер создания виртуальной машины, выбираете регион, размер, образ, настраиваете диск и

00:00:19.600 --> 00:00:25.000
сеть. Это уже, пожалуй, 50 кликов. Затем вы повторяете это для второй ВМ, настраиваете учетную

00:00:25.000 --> 00:00:29.880
запись хранения и правила Брандмауэра. И вот в чем дело. Каждый такой клик – это риск допустить

00:00:29.880 --> 00:00:34.920
ошибку. Выбрали не тот регион, приложение работает медленнее, чем нужно. Выбрали не тот размер ВМ,

00:00:35.140 --> 00:00:40.400
переплачиваете с первого же дня. Забыли закрыть порт, и вы сами не заметили, как открыли свою среду

00:00:40.400 --> 00:00:46.080
для интернета. Теперь умножьте это на три среды, разработка, тест, продакшн, и внезапно вы делаете

00:00:46.080 --> 00:00:52.160
не 50 кликов, а 150. И где-то в процессе продакшн перестает быть похожим на среду разработки.

00:00:52.320 --> 00:00:56.740
Настройка здесь, галочка там, небольшие различия, которые позже обернутся большой головной болью.

00:00:56.740 --> 00:01:00.060
Но что, если можно было бы описать всю настройку Azure в файле, вместо того,

00:01:00.180 --> 00:01:04.140
чтобы прокликовать все эти экраны? Что, если можно было бы запустить этот файл один раз и каждый

00:01:04.140 --> 00:01:08.260
раз получать один и тот же результат? Именно об этом мы сегодня и поговорим. К концу этого

00:01:08.260 --> 00:01:14.180
выпуска вы поймете, что такое инфраструктура, как код, почему команды Azure полагаются на нее и как

00:01:14.180 --> 00:01:19.820
начать использовать ее, не будучи разработчиком. Во что на самом деле обходится ручная подготовка

00:01:19.820 --> 00:01:25.840
ресурсов? Давайте разберем типичную настройку Azure. Вам нужна группа ресурсов, внутри нее – виртуальная сеть с парой

00:01:25.840 --> 00:01:30.820
подсетей. Затем две виртуальные машины, одна для веб-сервера, другая для базы данных и учетная

00:01:30.820 --> 00:01:35.560
запись хранения для данных приложения. На портале это полноценный день кликания мышкой. И вот

00:01:35.560 --> 00:01:39.800
проблема – каждый клик – это возможность совершить ошибку. Возможно, вы выбрали не тот регион,

00:01:39.980 --> 00:01:43.500
потому что в выпадающем списке по умолчанию стоит EastUS, а вам был нужен West Europe. Возможно,

00:01:43.680 --> 00:01:47.240
вы выбрали размер VM, который гораздо дороже того, что вам на самом деле нужно. Возможно,

00:01:47.420 --> 00:01:51.820
вы случайно оставили открытым для интернета порт управления. Такие ошибки случаются. Они случаются,

00:01:51.820 --> 00:01:54.920
потому что портал позволяет легко кликать быстро и сложно замедлиться, чтобы проверить свою

00:01:54.920 --> 00:01:58.440
работу. И настоящая цена – это не только время, которое вы тратите на исправление этих ошибок.

00:01:58.560 --> 00:02:01.160
Это время, которое вы тратите на повторение одних и тех же кликов для сред разработки,

00:02:01.260 --> 00:02:04.660
тестирования, промежуточной и рабочей. Потому что вот что происходит. В понедельник вы создаете

00:02:04.660 --> 00:02:08.100
среду разработки, это занимает три часа, и все работает идеально. Во вторник вы создаете

00:02:08.100 --> 00:02:12.300
среду тестирования. В этот раз вы чуть быстрее – 2 секунды половины часа, но забываете об одной

00:02:12.300 --> 00:02:15.960
настройке. Правило Брандмауэра, которое было открыто в разработке, закрыто в тестировании.

00:02:16.180 --> 00:02:20.780
Ваше приложение ведет себя иначе, и вы тратите час на отладку. К моменту, когда в пятницу вы добираетесь

00:02:20.780 --> 00:02:24.620
до рабочей среды, она совсем не похожа на среду разработки. Другие размеры виртуальных машин,

00:02:24.740 --> 00:02:28.180
другие конфигурации хранилища, пара настроек, которые вы изменили, потому что кто-то попросил

00:02:28.180 --> 00:02:32.080
попробовать кое-что на скорую руку. Это называется дрейфом конфигурации, и это естественный

00:02:32.080 --> 00:02:36.260
результат ручного создания сред. Настоящая проблема в том, что нельзя проверить историю кликов

00:02:36.260 --> 00:02:40.380
мышкой. Вы не можете откатить клик мышкой назад. Если через 6 недель что-то сломается в рабочей

00:02:40.380 --> 00:02:44.140
среде, вы не вспомните, какой флажок ставили или снимали. У вас не будет записи о том,

00:02:44.280 --> 00:02:48.060
что изменилось между средой разработки и рабочей средой. А что, если бы вы могли описать всю

00:02:48.060 --> 00:02:52.240
настройку Azure в файле вместо того, чтобы кликать по экранам? Один файл, в котором точно сказано,

00:02:52.380 --> 00:02:55.780
как должна выглядеть ваша среда. Запустите его один раз, получите тот же результат каждый раз.

00:02:55.960 --> 00:02:59.820
Запустите снова, получите тот же результат снова. Никакого дрейфа, никаких забытых настроек,

00:02:59.900 --> 00:03:04.060
никаких рабочих сред, которые не похожи на среду разработки. Инфраструктура как код — определение

00:03:04.060 --> 00:03:07.820
в одно предложение. Инфраструктура как код означает описание вашей инфраструктуры в файле,

00:03:07.960 --> 00:03:12.480
который Azure может прочитать и построить для вас. Вот и все. Одно предложение. Вы создаете файл,

00:03:12.480 --> 00:03:17.060
Azure читает его, и ваша среда появляется. Представьте это как офисные здания. Если бы вы хотели

00:03:17.060 --> 00:03:20.620
обустроить новый офис, вы могли бы ходить вокруг и говорить каждому работнику, куда поставить

00:03:20.620 --> 00:03:25.160
каждый стол и стул. Это ручной подход. Это работает, но медленно, и у каждого в итоге получится

00:03:25.160 --> 00:03:29.700
немного разная расстановка. Или вы могли бы вручить им чертеж. Один лист бумаги, где точно сказано,

00:03:29.860 --> 00:03:33.880
что и где должно находиться. Каждая комната идентична, потому что все следовали одному плану.

00:03:34.000 --> 00:03:39.320
Ваш файл IAC и есть этот чертеж. Это единый источник истины для всей вашей среды АЗУ. Все,

00:03:39.320 --> 00:03:43.240
что нужно вашей среде, группы ресурсов, виртуальные сети, виртуальные машины,

00:03:43.240 --> 00:03:48.000
учетные записи хранения, правила Брандмауэра, все это в одном файле. Теперь здесь есть важное

00:03:48.000 --> 00:03:52.580
различие. IAC использует так называемый декларативный подход. Это модный способ сказать,

00:03:52.820 --> 00:03:56.660
что вы сообщаете АЗУ, что именно хотите получить, а не как это построить шаг за шагом.

00:03:56.800 --> 00:04:01.940
Вы не говорите, создай группу ресурсов, затем виртуальную сеть в ней, а потом подсеть внутри нее.

00:04:02.100 --> 00:04:05.840
Вы говорите, мне нужна группа ресурсов с виртуальной сетью, в которой есть подсеть.

00:04:05.840 --> 00:04:10.380
АЗУ сама определяет порядок действий. Это отличается от скриптов, которые системные администраторы

00:04:10.380 --> 00:04:14.960
использовали годами. Скрипты императивны. Они пошагово указывают системе, что именно нужно

00:04:14.960 --> 00:04:19.360
сделать. Сделай это, затем-то, потом вот это, и если один шаг не удастся, все ломается.

00:04:19.560 --> 00:04:24.340
IAC – это полная противоположность. Вы описываете конечное состояние, а система сама решает,

00:04:24.460 --> 00:04:29.420
как его достичь. Вот наглядный пример. Вместо ввода 50 отдельных команд CLI для создания

00:04:29.420 --> 00:04:34.500
виртуальной машины вы пишете что-то вроде «Мне нужна виртуальная машина с 8 гигабайтов АЗУ на

00:04:34.500 --> 00:04:40.780
Ubuntu 22.04», подключенная к этой сети и с привязанным хранилищем. Вот и все. Одно описание

00:04:40.780 --> 00:04:45.440
вместо сотни команд. И это важно именно для АЗУ, потому что портал позволяет так легко начать

00:04:45.440 --> 00:04:50.040
работу. Вы можете запустить виртуальную машину за 10 минут в несколько кликов. Но портал не

00:04:50.040 --> 00:04:55.360
масштабируется. Когда вам нужно 10 сред вместо одной, портал становится обузой. IAC – это способ

00:04:55.360 --> 00:04:59.960
вырваться из этой ловушки. Звучит полезно, правда? Но какие инструменты Microsoft на самом деле

00:04:59.960 --> 00:05:04.940
дает для создания этих файлов чертежей? Набор инструментов IAC для АЗУ, ARM, BSIB и слон в

00:05:04.940 --> 00:05:09.160
комнате. Итак, какие инструменты Microsoft на самом деле дает для создания этих файлов чертежей?

00:05:09.280 --> 00:05:13.560
Первый из них называется шаблонами ARM. ARM расшифровывается как Azure Resource Manager,

00:05:13.740 --> 00:05:18.340
и эти шаблоны существуют с самого начала. Они написаны на JSON, формате данных, который похож на

00:05:18.340 --> 00:05:23.480
конфигурационный файл из 2015 года. Много фигурных скобок, много квадратных скобок, много отступов.

00:05:23.620 --> 00:05:28.700
Если вы хоть раз видели JSON-файл, вы понимаете, о чем я. Он функционален, но его неприятно читать.

00:05:28.700 --> 00:05:33.380
Шаблоны ARM до сих пор широко используются, особенно в корпоративной среде. Крупные компании

00:05:33.380 --> 00:05:37.920
годами вкладывались в создание своих библиотек шаблонов и не собираются выбрасывать эту работу.

00:05:38.100 --> 00:05:43.760
Но если вы новичок, первый взгляд на шаблоны ARM может испугать. Он слишком многословен. Его легко

00:05:43.760 --> 00:05:48.380
сломать. Одна пропущенная запятая, и все перестает работать. Писать его вручную – мучение.

00:05:48.560 --> 00:05:54.580
Microsoft признала эту проблему и создала BSIB. BSIB – это ответ Microsoft на то, что шаблоны ARM слишком

00:05:54.580 --> 00:05:59.920
сложны. Это более новый язык, который компилируется в шаблоны ARM, но его синтаксис намного чище.

00:06:00.060 --> 00:06:04.640
Это выглядит как настоящий код. Вы пишете что-то вроде ресурс MyVM Microsoft.

00:06:05.640 --> 00:06:09.320
Compute Virtual Machines вместо страниц, вложенного JSON.

00:06:10.320 --> 00:06:15.700
Он создан в первую очередь для людей. Теперь есть еще один вариант, о котором вы услышите – Terraform.

00:06:15.860 --> 00:06:20.100
Terraform – это инструмент от компании HashiCorp, который работает с Azure и другими облаками.

00:06:20.100 --> 00:06:25.660
Если вам нужно управлять инфраструктурой в AWS, Google Cloud и Azure одновременно, Terraform – ваш лучший

00:06:25.660 --> 00:06:30.340
выбор. Он более мобилен, но за эту мобильность приходится платить. Terraform добавляет уровень

00:06:30.340 --> 00:06:36.340
абстракции между вами и Azure. Вам нужно изучить собственный язык Terraform, HCL, помимо самого Azure.

00:06:36.500 --> 00:06:42.000
Он мощный, но привносит свою сложность. Итак, что выбрать новичку? Если вы работаете только с Azure,

00:06:42.220 --> 00:06:47.060
начните с BSIB. Причина проста – нативная интеграция. BSIB создан Microsoft специально для Azure.

00:06:47.060 --> 00:06:51.460
В нем меньше лишних компонентов. Он получает полную поддержку Microsoft. И поскольку он

00:06:51.460 --> 00:06:55.720
компилируется в шаблоны ARM, вы ни к чему не привязаны. Вы всегда сможете перейти на обычные

00:06:55.720 --> 00:07:00.520
шаблоны ARM, если потребуется. BSIB – это путь наименьшего сопротивления для тех, кто только

00:07:00.520 --> 00:07:05.860
начинает. Вот как эти инструменты работают на практике. Вы создаете файл, BSIB, шаблоны ARM или

00:07:05.860 --> 00:07:11.880
что выберете. Затем запускаете команду. Для BSIB это команда az-deployment-group-create. Azure считывает

00:07:11.880 --> 00:07:16.700
ваш файл, сравнивает его с тем, что уже есть, и создает недостающие или меняет отличающиеся.

00:07:16.700 --> 00:07:21.140
Вам не нужно указывать Azure, в каком порядке выполнять действие. Он определяет это самостоятельно.

00:07:21.220 --> 00:07:25.340
И вот здесь начинается самое интересное. Вы можете подключить это к CI, CD-конвейеру,

00:07:25.500 --> 00:07:29.260
непрерывной интеграции и развертыванию. Это значит, что каждый раз, когда вы отправляете

00:07:29.260 --> 00:07:33.560
изменения в репозиторий, Azure автоматически запускает ваш файл IAC и обновляет инфраструктуру.

00:07:33.700 --> 00:07:37.640
Никаких ручных действий, никакого входа на портал, только изменения кода, автоматически

00:07:37.640 --> 00:07:42.120
попадающие в продакшн. Итак, у вас есть файл, описывающий вашу инфраструктуру. Вы можете запустить

00:07:42.120 --> 00:07:45.760
его и получить стабильный результат. Вы даже можете автоматизировать все это с помощью конвейера.

00:07:45.760 --> 00:07:50.280
Но что это дает на самом деле? Вот в чем заключается настоящая мощь. Что система контроля

00:07:50.280 --> 00:07:54.040
версий делает для вашей среды Azure? Вот о чем люди говорят недостаточно часто.

00:07:54.280 --> 00:07:58.900
Настоящая суперсила IAC — это не сам формат шаблона. Это не BISIP против ARM или против

00:07:58.900 --> 00:08:03.700
Terraform. Настоящая суперсила — это контроль версий. Когда вы храните файлы IAC в репозитории,

00:08:03.860 --> 00:08:07.600
таком как GitHub или Azure Repos, каждое изменение становится очлеживаемым.

00:08:07.760 --> 00:08:12.600
Кто, что, когда и зачем изменил? Вы получаете полную историю всех изменений вашей

00:08:12.600 --> 00:08:16.040
инфраструктуры с первого дня. А это значит, что вы можете выполнить откат.

00:08:16.220 --> 00:08:20.340
Если развертывание что-то ломает, вам не нужно гадать, что пошло не так. Вам не нужно копаться

00:08:20.340 --> 00:08:24.200
в журналах аудита портала в надежде найти ответ. Вы просто возвращаетесь к последней рабочей

00:08:24.200 --> 00:08:28.800
версии файла IAC и повторно развертываете его. Проблема исчезает. Это-то, чего просто невозможно

00:08:28.800 --> 00:08:32.840
добиться обычными кликами мыши. Это также означает, что ваши среды остаются согласованными.

00:08:33.020 --> 00:08:36.760
Среды разработки, тестирования и производства создаются из одних и тех же файлов. Не из похожих файлов,

00:08:36.940 --> 00:08:41.180
не из тех, что были одинаковыми, но со временем разошлись. Из одних и тех же файлов вы развертываете

00:08:42.600 --> 00:08:47.320
когда готовы к тесту, развертываете те же файлы в тестовой подписке. Когда готовы к продакшену,

00:08:47.520 --> 00:08:52.420
снова развертываете те же самые файлы. Каждая среда идентична, потому что все они построены по

00:08:52.420 --> 00:08:56.900
одному чертежу. А поскольку эти файлы хранятся в репозитории, вы можете проводить код-ревью

00:08:56.900 --> 00:09:01.440
инфраструктуры. Прежде чем кто-либо развернет изменения, другой член команды должен их проверить

00:09:01.440 --> 00:09:06.120
и одобрить. Это позволяет находить ошибки до того, как они попадут в вашу среду. Это тот же процесс,

00:09:06.360 --> 00:09:09.940
что разработчики применяют к программному коду, теперь для вашей инфраструктуры Азур.

00:09:09.940 --> 00:09:14.160
Вот реальный пример. Кто-то из вашей команды случайно открывает доступ к учетной записи хранения

00:09:14.160 --> 00:09:18.740
для всех. Без IAC вы можете не заметить этого, пока не придет счет или кто-то не сообщит об утечке

00:09:18.740 --> 00:09:23.720
данных. С IAC это изменение сразу видно в репозитории. Оно проходит проверку кода. Кто-то замечает

00:09:23.720 --> 00:09:27.680
это и говорит «Эй, эта учетная запись хранения не должна быть публичной». Изменение блокируется до того,

00:09:27.820 --> 00:09:31.700
как оно попадет в продакшен. А если оно все же проскочит, вы сможете откатить его за считанные секунды.

00:09:31.820 --> 00:09:35.100
Вы даже можете использовать стратегии ветвления. Хотите поэкспериментировать с новой

00:09:35.100 --> 00:09:39.020
конфигурацией. Создайте отдельную ветку, внесите изменения, разверните в тестовой среде и проверьте

00:09:39.020 --> 00:09:43.200
работу. Если все работает, слейте изменения с основной веткой. Если нет, просто удалите ветку и

00:09:43.200 --> 00:09:47.080
попробуйте что-то другое. Ваша производственная среда не затрагивается, пока вы не будете уверены

00:09:47.080 --> 00:09:51.640
в безопасности изменений. Согласованность – это отлично, но IAC также делает вашу среду Азур более

00:09:51.640 --> 00:09:56.040
безопасной. И это важно независимо от того, управляет всем один человек или целая команда.

00:09:56.380 --> 00:10:01.640
Безопасность как основа, а не случайность. Вот кое-что, что многих удивляет. При использовании IAC

00:10:01.640 --> 00:10:06.320
безопасность – это не то, что добавляется позже. Она встроена в шаблон с самого начала. Вместо

00:10:06.320 --> 00:10:09.480
того, чтобы не забыть включить шифрование для каждой новой учетной записи хранения,

00:10:09.680 --> 00:10:13.440
оно уже есть в вашем файле. Вместо того, чтобы надеяться на правильную настройку Брандмауэра,

00:10:13.620 --> 00:10:17.660
правила прописаны и применяются каждый раз автоматически. У этой концепции есть название

00:10:17.660 --> 00:10:21.380
«Политика как код». Вы встраиваете правила безопасности непосредственно в конвейер

00:10:21.380 --> 00:10:25.060
развертывания. Поэтому каждый раз, когда кто-то пытается создать учетную запись хранения,

00:10:25.200 --> 00:10:29.500
конвейер проверяет включение HTTPS, активацию шифрования и блокировку публичного доступа.

00:10:29.500 --> 00:10:32.940
Если шаблон не соответствует этим правилам, развертывание завершается с ошибкой.

00:10:33.220 --> 00:10:37.460
Небезопасная конфигурация никогда не попадет в вашу среду. Подумайте, что это заменяет.

00:10:37.680 --> 00:10:41.820
Десятки ручных проверок, надежду на то, что кто-то поставит нужную галочку и последующий

00:10:41.820 --> 00:10:45.860
вудит этих галочек кем-то другим. Все это уходит в прошлое. Один безопасный шаблон,

00:10:46.080 --> 00:10:50.180
один набор политик, и каждое развертывание автоматически соответствует базовым требованиям

00:10:50.180 --> 00:10:54.020
безопасности. Но вот что по-настоящему интересно – аварийное восстановление. Файл,

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

00:10:57.820 --> 00:11:01.540
скомпрометирует вашу среду, вам не придется тратить дни на выяснение того, что он изменил и как

00:11:01.540 --> 00:11:05.240
это исправить. Вы просто все удаляете и разворачиваете заново из вашего файла IAC.

00:11:05.480 --> 00:11:09.340
Ваша чистая среда готова за считанные минуты. Это невозможно, если инфраструктура была построена

00:11:09.340 --> 00:11:12.540
вручную. А поскольку все находится в системе контроля версий, у вас есть журнал аудита.

00:11:12.700 --> 00:11:16.700
Каждое изменение вашей инфраструктуры записывается. Кто внес изменения, когда и зачем – это

00:11:16.700 --> 00:11:19.760
доказательство соответствия требованиям без необходимости заполнять электронные таблицы.

00:11:19.760 --> 00:11:23.560
Для небольших команд без штатных специалистов по безопасности это мощный множитель усилий.

00:11:23.560 --> 00:11:27.260
Вы получаете методы защиты корпоративного уровня, не нанимая команду специалистов по безопасности

00:11:27.260 --> 00:11:31.280
корпоративного уровня. Все это звучит отлично на бумаге, но начать может показаться сложным.

00:11:31.420 --> 00:11:35.520
Позвольте предложить вам реалистичный путь вперед. Как начать, ничего не сломав?

00:11:35.640 --> 00:11:39.840
Правило первое. Не начинайте с производственной среды. Я не могу подчеркнуть это достаточно сильно.

00:11:40.040 --> 00:11:44.300
IAC – это мощный, но новый инструмент. Вы будете совершать ошибки. Делайте их там,

00:11:44.300 --> 00:11:49.080
где это не критично. Выберите небольшую часть своей среды Azure, группу ресурсов с одной виртуальной

00:11:49.080 --> 00:11:53.520
машиной или учетную записью хранения, что-то простое, что у вас уже работает и в чем вы уверены.

00:11:53.680 --> 00:11:58.540
Вот в чем секрет. Портал Azure может генерировать шаблоны ARM на основе ваших существующих ресурсов.

00:11:58.640 --> 00:12:03.260
Вы переходите в группу ресурсов, нажимаете «Экспорт шаблона» и Azure предоставляет JSON-файл,

00:12:03.360 --> 00:12:07.980
описывающий все содержимое этой группы. Он не идеален. Экспортированный шаблон часто содержит

00:12:07.980 --> 00:12:13.340
лишнее, но это хорошая отправная точка. Вы берете то, что создали вручную, и преобразуете это в код.

00:12:13.340 --> 00:12:18.220
Это подход с обратной разработкой, и это самый быстрый способ обучения. Начните с BISIP и бесплатных

00:12:18.220 --> 00:12:22.720
инструментов Azure. У Microsoft есть расширение VS Code для BISIP, которое обеспечивает подсветку синтаксиса,

00:12:22.720 --> 00:12:26.320
автодополнение и визуальный предпросмотр того, что вы создаете. Вы можете увидеть свою

00:12:26.320 --> 00:12:30.420
виртуальную сеть и подсети в виде диаграммы еще до развертывания. Это значительно упрощает

00:12:30.420 --> 00:12:34.260
понимание того, что на самом деле делает ваш код. Используйте отдельную подписку для

00:12:34.260 --> 00:12:38.080
тестирования. У большинства подписок Azure есть лимиты расходов и бесплатные кредиты.

00:12:38.240 --> 00:12:42.700
Создайте тестовую подписку, разверните там инфраструктуру как код, ломайте, чините и учитесь.

00:12:42.700 --> 00:12:45.860
Когда почувствуете уверенность, переходите к непроизводственной подписке.

00:12:46.100 --> 00:12:50.320
Производственная среда в последнюю очередь. А вот эта часть может вас удивить. Вам не обязательно

00:12:50.320 --> 00:12:53.880
быть инженером-программистом, чтобы заниматься этим. Концепция гражданского разработчика

00:12:53.880 --> 00:12:57.400
вполне реальна. BISIP был создан для тех, кто управляет инфраструктурой Azure, а не для

00:12:57.400 --> 00:13:01.280
профессиональных программистов. Он легко читается. В нем меньше формальностей, чем в традиционных

00:13:01.280 --> 00:13:05.040
языках программирования. Он сфокусирован только на Azure и ни на чем другом. Если вы понимаете,

00:13:05.240 --> 00:13:08.020
что такое виртуальная машина, вы сможете научиться описывать ее на BISIP.

00:13:08.020 --> 00:13:11.960
Ваш первый практический проект – автоматизируйте создание и удаление среды разработки.

00:13:12.120 --> 00:13:16.820
Напишите файл BISIP, который создает среду, разверните ее, используйте, затем удалите и разверните

00:13:16.820 --> 00:13:21.220
снова. Проделайте это несколько раз, пока процесс не станет привычным. Это упражнение научит

00:13:21.220 --> 00:13:25.800
вас большему об инфраструктуре, как коде, чем любой учебник. Несколько советов для начинающих.

00:13:25.960 --> 00:13:29.780
Коммите рано и коммите часто. Каждый раз, когда какая-то часть вашего шаблона заработала,

00:13:29.920 --> 00:13:33.140
сохраняйте ее в репозиторий. Это создает контрольные точки, к которым можно вернуться.

00:13:33.140 --> 00:13:35.880
И всегда запускайте команду предварительного просмотра перед развертыванием.

00:13:36.040 --> 00:13:40.380
В BISIP эта команда – вот АЕФ. Она показывает, что именно изменится, прежде чем изменения

00:13:40.380 --> 00:13:45.180
вступят в силу. Никаких сюрпризов. Даже при лучших намерениях начинающие часто попадают

00:13:45.180 --> 00:13:48.360
в ловушке. Позвольте мне избавить вас от ночных сеансов отладки.

00:13:48.500 --> 00:13:51.540
Три ошибки, которые будут вас преследовать, и способы их избежать.

00:13:51.700 --> 00:13:54.620
Ошибка номер один – классика, жесткое кодирование секретов.

00:13:54.720 --> 00:13:58.720
Вы торопитесь. Нужно срочно запустить шаблон, и вы вписываете пароль от базы данных

00:13:58.720 --> 00:14:02.480
прямо в файл. Все работает. Вы идете дальше. И теперь ваш пароль лежит в репозитории

00:14:02.480 --> 00:14:06.100
инфраструктуры, доступной всем, у кого есть права. Очевидно, если смотреть со стороны,

00:14:06.280 --> 00:14:09.660
правда, но это невероятно легко сделать, когда вы сосредоточены на том, чтобы все просто

00:14:09.660 --> 00:14:14.320
заработало. Решение – Azure Keywall. И BISIP, и шаблоны ARM могут извлекать секреты

00:14:14.320 --> 00:14:18.340
напрямую из Keywall во время развертывания. Ваш файл просто указывает взять пароль из

00:14:18.340 --> 00:14:22.340
этого хранилища, вместо того, чтобы содержать сам пароль. Секрет никогда не попадет в ваш

00:14:22.340 --> 00:14:26.760
репозиторий. Никогда не добавляйте пароли, строки подключения или API-ключи в свои файлы

00:14:26.760 --> 00:14:32.380
IAC. Всегда используйте Keywall. Ошибка номер два – относиться к IAC как к одноразовому скрипту.

00:14:32.540 --> 00:14:36.320
Вы пишете шаблон, развертываете его, все работает, и вы больше никогда в него не заглядываете.

00:14:36.540 --> 00:14:41.140
Спустя полгода что-то ломается. Вы открываете файл и понятия не имеете, что делает половина кода.

00:14:41.140 --> 00:14:46.460
Этот параметр, парам 1, без понятия. Тот ресурс с загадочным именем, ни малейшего представления.

00:14:46.600 --> 00:14:50.960
Пишите IAC так, будто через полгода его будет поддерживать кто-то другой, ведь этим, другим,

00:14:51.100 --> 00:14:55.440
скорее всего, будете вы сами, и вы все забудете. Добавляйте комментарии, используйте понятные

00:14:55.440 --> 00:14:58.800
имена вместо сокращений. Делайте файлы небольшими и узкоспециализированными.

00:14:58.940 --> 00:15:02.160
Файл BISIP для создания виртуальной сети должен касаться только виртуальной сети,

00:15:02.320 --> 00:15:06.200
а не всего дата-центра. Ошибка номер три – обход конвейера ради быстрых исправлений.

00:15:06.360 --> 00:15:09.820
Портал всегда манит своим удобством. Вам нужно изменить всего одну настройку.

00:15:09.820 --> 00:15:13.140
5 минут на правку шаблона, коммит и развертывание через конвейер.

00:15:13.220 --> 00:15:16.780
Или можно просто зайти на портал, сделать три клика и управиться за 30 секунд.

00:15:16.940 --> 00:15:21.940
Это быстрое изменение порождает дрейф конфигурации. Ваш код говорит одно, а реальность – другое.

00:15:22.060 --> 00:15:25.860
При следующем развертывании из шаблона Азур попытается отменить ваше ручное изменение,

00:15:26.040 --> 00:15:29.200
или, что еще хуже, не заметит его, и окружения начнут расходиться,

00:15:29.360 --> 00:15:32.020
пока продакшн не станет работать совсем иначе, чем разработка.

00:15:32.260 --> 00:15:35.980
Дисциплина проста. Вносите изменения в код. Развертываете через конвейер,

00:15:35.980 --> 00:15:40.420
даже если это займет лишние пять минут. Эти пять минут сэкономят вам часы отладки в будущем.

00:15:40.580 --> 00:15:44.080
Бонусный совет – всегда запускайте команду предварительного просмотра перед внесением изменений.

00:15:44.240 --> 00:15:48.520
В BISIP эта команда What.IF, она точно показывает, что будет создано, изменено или удалено.

00:15:48.680 --> 00:15:51.400
Никаких сюрпризов. Вы видите последствия до того, как они произойдут.

00:15:51.520 --> 00:15:55.060
Это IAC простыми словами. Никакого жаргона. Никакой маркетинговой воды.

00:15:55.220 --> 00:15:57.820
Просто практический инструмент, который упрощает вашу жизнь в Азур.

00:15:57.980 --> 00:15:59.480
Что стоит попробовать на этой неделе?

00:15:59.640 --> 00:16:00.800
Итак, что мы обсудили.

00:16:00.800 --> 00:16:05.560
IAC превращает вашу инфраструктуру Азур в контролируемый версиями, воспроизводимый и безопасный проект.

00:16:05.720 --> 00:16:08.880
Один файл, описывающий все, развертываемый одинаково каждый раз.

00:16:09.060 --> 00:16:12.920
Ваше задание на эту неделю – экспортируйте один существующий ресурс Азур, как ARM-шаблон.

00:16:13.100 --> 00:16:16.100
Откройте его в VS Code. Попробуйте понять, что он делает.

00:16:16.280 --> 00:16:19.600
Это упражнение даст вам больше знаний, чем любое мое объяснение.

00:16:19.760 --> 00:16:23.940
В следующей части этой серии мы пошагово разберем создание вашего первого файла BISIP.

00:16:24.060 --> 00:16:27.660
Подписывайтесь на любимой платформе подкастов и поделитесь этим выпуском с коллегой,

00:16:27.660 --> 00:16:29.480
который до сих пор все делает через портал.
