WEBVTT

00:00:00.000 --> 00:00:02.980
Добро пожаловать в очередной выпуск Microsoft NoLedge на Getas на M365.

00:00:03.100 --> 00:00:04.980
Меня зовут Мирко Питерс, и я ваш ведущий.

00:00:05.100 --> 00:00:08.260
Сегодняшняя тема — это то, о чем слышали почти все, но мало кто может внятно объяснить.

00:00:08.420 --> 00:00:10.020
Что же такое Azure DevOps на самом деле?

00:00:10.160 --> 00:00:12.520
Это просто инструмент для разработчиков или нечто гораздо большее?

00:00:12.620 --> 00:00:14.380
Итак, вы хотите создать программное обеспечение.

00:00:14.640 --> 00:00:18.400
Может быть, это веб-сайт, мобильное приложение или решение для оптимизации работы вашей компании.

00:00:18.600 --> 00:00:20.240
Вы садитесь, чтобы все спланировать.

00:00:20.420 --> 00:00:23.260
Вам нужен инструмент для отслеживания задач, место для хранения кода,

00:00:23.520 --> 00:00:26.580
способ тестирования работы и возможность передать готовый продукт пользователям.

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

00:00:30.920 --> 00:00:34.560
Один для задач, другой для кода, третий для тестирования, четвертый для развертывания,

00:00:34.720 --> 00:00:36.540
и никто из них не общается друг с другом.

00:00:36.640 --> 00:00:37.780
Это настоящий хаос.

00:00:37.940 --> 00:00:40.600
В Microsoft увидели этот беспорядок и создали решение.

00:00:40.800 --> 00:00:44.440
Оно называется Azure DevOps, и это не просто очередной инструмент в вашу стопку.

00:00:44.580 --> 00:00:48.360
Это единая связанная платформа, которая охватывает весь жизненный цикл разработки,

00:00:48.520 --> 00:00:51.980
планирования, написания кода, тестирования и развертывания в одном месте.

00:00:51.980 --> 00:00:55.260
К концу этого выпуска вы поймете, что такое Azure DevOps на самом деле

00:00:55.260 --> 00:00:57.820
и как пять его основных компонентов сочетаются друг с другом.

00:00:57.920 --> 00:01:00.060
Представьте себе это как современные офисные здания.

00:01:00.240 --> 00:01:02.780
Word и Excel — это отдельные кабинеты, в которых вы работаете.

00:01:02.940 --> 00:01:06.580
Microsoft 365 — это все здания целиком с системой безопасности и архивами.

00:01:06.720 --> 00:01:08.520
Azure DevOps — это та же самая идея.

00:01:08.640 --> 00:01:11.580
Это полноценное здание для разработки ПА, а не просто отдельная комната.

00:01:11.740 --> 00:01:14.000
Итак, что же именно представляет собой Azure DevOps?

00:01:14.200 --> 00:01:15.580
Вот самое простое определение.

00:01:15.760 --> 00:01:19.240
Azure DevOps — это связанная платформа для всего жизненного цикла разработки программного обеспечения.

00:01:19.240 --> 00:01:21.480
Звучит сложно, поэтому давайте разберем подробнее.

00:01:21.480 --> 00:01:25.560
20 лет назад, если вы хотели создать ПА, вам приходилось покупать отдельные продукты для всего.

00:01:25.740 --> 00:01:28.460
Один инструмент для отслеживания ошибок, другой — для управления кодом,

00:01:28.600 --> 00:01:31.880
третий — для автоматизации сборки, четвертый — для тестирования, пятый — для развертывания,

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

00:01:35.340 --> 00:01:39.880
В Microsoft посмотрели на эту сложность и подумали, что если объединить все эти сервисы под одной крышей,

00:01:39.980 --> 00:01:41.320
так они создали Azure DevOps.

00:01:41.600 --> 00:01:44.320
Это не один инструмент, а пять сервисов, которые работают вместе.

00:01:44.320 --> 00:01:47.800
Azure Boards для планирования, Azure Repost для кода, Azure Pipelines для автоматизации,

00:01:47.920 --> 00:01:50.660
Azure Test Plans для контроля качества, Azure Artefacts для обмена пакетами.

00:01:50.760 --> 00:01:53.120
У каждого своя задача, но все они связаны между собой.

00:01:53.280 --> 00:01:54.880
Вернемся к аналогии с офисным зданием.

00:01:55.100 --> 00:01:57.140
Стойка регистрации управляет тем, кто входит в здание.

00:01:57.280 --> 00:01:58.800
Это и есть ваши службы идентификации.

00:01:58.940 --> 00:02:00.600
Офисы — это места, где работают люди.

00:02:00.740 --> 00:02:01.880
Это доски и репозитории.

00:02:02.040 --> 00:02:03.800
В почтовой комнате обрабатывают посылки.

00:02:03.920 --> 00:02:04.660
Это артефакты.

00:02:04.840 --> 00:02:06.460
Служба безопасности охраняет здание.

00:02:06.620 --> 00:02:08.520
Это ваши средства контроля доступа и политики.

00:02:08.620 --> 00:02:10.600
У каждого своя задача, но все они под одной крышей.

00:02:10.600 --> 00:02:11.940
Они обмениваются информацией.

00:02:12.060 --> 00:02:13.040
Они работают сообща.

00:02:13.180 --> 00:02:14.020
В этом-то все и дело.

00:02:14.200 --> 00:02:15.760
А вот самая лучшая часть для новичков.

00:02:15.900 --> 00:02:17.620
В Azure DevOps есть бесплатный тариф.

00:02:17.660 --> 00:02:20.880
Вы можете создать аккаунт, начать проект и использовать основные функции бесплатно.

00:02:20.960 --> 00:02:22.920
Пять пользователей получают полный доступ бесплатно.

00:02:23.060 --> 00:02:25.640
Неограниченное число заинтересованных лиц получают ограниченный доступ бесплатно.

00:02:25.720 --> 00:02:28.620
Так что вы можете начать прямо сегодня без затрат и понять, подходит ли это вам.

00:02:28.760 --> 00:02:30.000
Кредитная карта не требуется.

00:02:30.220 --> 00:02:31.540
Никаких звонков от отдела продаж.

00:02:31.660 --> 00:02:34.380
Просто перейдите на dev.azur.com и создайте учетную запись.

00:02:34.380 --> 00:02:39.040
Давайте пройдемся по пяти службам по очереди, начиная с места, где начинается вся ваша работа.

00:02:39.160 --> 00:02:41.580
Azure Boards — командный центр вашего проекта.

00:02:41.580 --> 00:02:44.940
Итак, Azure Boards — это место, где вы планируете и очлеживаете свою работу.

00:02:45.140 --> 00:02:47.240
Считайте его командным центром вашего проекта.

00:02:47.380 --> 00:02:51.680
Если вы когда-либо использовали стикеры на стене для отслеживания задач, вы уже понимаете суть.

00:02:51.820 --> 00:02:54.220
Но вместо бумажных стикеров, которые отклеиваются и теряются,

00:02:54.360 --> 00:02:58.280
Boards дает вам цифровую канбан-доску, которую каждый в команде может видеть и обновлять в реальном времени.

00:02:58.480 --> 00:02:59.620
Давайте разберем подробнее.

00:02:59.780 --> 00:03:01.740
Вы начинаете с создания рабочих элементов.

00:03:01.740 --> 00:03:04.220
Рабочий элемент — это все, что вам нужно отслеживать.

00:03:04.480 --> 00:03:07.860
Пользовательская история, функция, эпик, задача или ошибка.

00:03:07.860 --> 00:03:12.100
У каждого есть поля для описания, приоритета, статуса и ответственного лица.

00:03:12.300 --> 00:03:16.920
Вы организуете эти элементы в бэклог, приоритизированный список всего, что нужно сделать.

00:03:17.120 --> 00:03:18.780
Вы можете группировать их в иерархии.

00:03:18.960 --> 00:03:23.120
Эпики вверху, функции под ними, пользовательские истории под ними и задачи под историями.

00:03:23.220 --> 00:03:26.160
Это дает ясное представление о том, что и зачем вы создаете.

00:03:26.380 --> 00:03:27.760
Затем вы планируете спринты.

00:03:27.940 --> 00:03:31.040
Спринт — это фиксированный период времени, обычно две недели,

00:03:31.280 --> 00:03:33.420
когда команда обязуется выполнить набор задач.

00:03:33.600 --> 00:03:36.820
Вы перетаскиваете элементы из бэклога в спринт, и план готов.

00:03:36.820 --> 00:03:39.520
Каждый знает, над чем он работает и к какому сроку.

00:03:39.620 --> 00:03:40.840
У вас также есть запросы.

00:03:40.980 --> 00:03:43.380
Запросы позволяют искать и фильтровать ваши рабочие элементы.

00:03:43.500 --> 00:03:46.160
Покажи мне все ошибки, назначенные Сари, с высоким приоритетом.

00:03:46.280 --> 00:03:49.300
Покажи мне все пользовательские истории в текущем спринте, которые все еще активны.

00:03:49.440 --> 00:03:51.820
Запросы мощны тем, что превращают данные в ответы.

00:03:51.900 --> 00:03:54.840
Вы можете сохранять их, делиться ими и использовать для создания дашбортов.

00:03:54.940 --> 00:03:56.480
А на дашбордах все собирается воедино.

00:03:56.620 --> 00:03:58.500
Вы можете создавать настраиваемые панели мониторинга с виджетами,

00:03:58.600 --> 00:04:01.760
отображающими диаграммы сгорания задач, скорость работы, количество рабочих элементов и многое другое.

00:04:01.760 --> 00:04:05.540
Ваша команда получает актуальное представление о ходе работы, и никому не нужно писать отчет о состоянии.

00:04:05.640 --> 00:04:06.980
Позвольте привести быстрый пример.

00:04:07.120 --> 00:04:09.340
Представьте небольшую команду, создающую веб-сайт.

00:04:09.520 --> 00:04:12.560
Владелец продукта создает эпик под названием «Портал клиента».

00:04:12.560 --> 00:04:16.640
Внутри него создаются функции, такие как регистрация пользователя и история заказов.

00:04:16.780 --> 00:04:19.800
Для функции регистрации пользователя создаются пользовательские истории.

00:04:20.060 --> 00:04:21.020
Например, как клиент.

00:04:21.180 --> 00:04:23.340
Я хочу создать учетную запись по электронной почте.

00:04:23.500 --> 00:04:26.180
В рамках этой истории разработчики создают задачи.

00:04:26.300 --> 00:04:30.960
Создать форму регистрации, настроить проверку электронной почты, написать модульные тесты.

00:04:30.960 --> 00:04:33.060
Каждая задача назначается исполнителю.

00:04:33.180 --> 00:04:35.160
Команда очлеживает прогресс на канбан-доске.

00:04:35.320 --> 00:04:38.740
Каждый может видеть, что уже сделано, что находится в процессе, а что запланировано.

00:04:38.860 --> 00:04:41.320
А теперь сравните это с использованием Excel или доски.

00:04:41.460 --> 00:04:42.360
Excel статичен.

00:04:42.500 --> 00:04:45.720
Вы отправляете таблицу по почте, кто-то обновляет ее и отправляет обратно.

00:04:45.860 --> 00:04:47.480
И к моменту получения она уже устаревает.

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

00:04:50.580 --> 00:04:53.180
Она ни с чем не связана, и если кто-то что-то сотрет, это будет потеряно.

00:04:53.320 --> 00:04:54.760
Бордс — это инструмент в реальном времени.

00:04:54.920 --> 00:04:56.040
В нем можно вести поиск.

00:04:56.040 --> 00:04:58.260
Он связан с вашим кодом, тестами и развертываниями.

00:04:58.320 --> 00:05:00.860
Когда кто-то обновляет рабочий элемент, все видят это мгновенно.

00:05:01.040 --> 00:05:05.160
Итак, вы спланировали работу, знаете, что нужно создать, но вам нужно место для хранения самого кода.

00:05:05.300 --> 00:05:07.040
И здесь на помощь приходит Azure Repos.

00:05:07.200 --> 00:05:09.280
Azure Repos — постоянный дом для вашего кода.

00:05:09.480 --> 00:05:13.560
Итак, вы спланировали работу, знаете, что нужно создать, но вам нужно место для хранения самого кода.

00:05:13.680 --> 00:05:15.400
И здесь на помощь приходит Azure Repos.

00:05:15.540 --> 00:05:18.460
Azure Repos — это контроль версии для вашего кода с использованием Git.

00:05:18.460 --> 00:05:21.680
Git — отраслевой стандарт, и большинство разработчиков уже используют его.

00:05:21.680 --> 00:05:25.540
Repos предоставляет место для размещения ваших репозиторий в Git прямо внутри Azure Defops.

00:05:25.680 --> 00:05:29.740
Приведем аналогию с написанием книги. Представьте, что вы пишете книгу с командой авторов.

00:05:29.920 --> 00:05:33.260
Вы могли бы пересылать главы друг другу по почте. Кто-то правит третью главу,

00:05:33.380 --> 00:05:37.760
отправляет по почте, кто-то другой снова правит ее, и вскоре у вас появляются файлы с названиями

00:05:37.760 --> 00:05:42.300
«Финальная версия третьей главы V2 отправлена актуальная», «Док», и никто не знает, какая версия

00:05:42.300 --> 00:05:46.300
настоящая». Именно так выглядела разработка подопоявления систем контроля версий.

00:05:46.420 --> 00:05:50.980
С Git в Azure Repos все работают с одним центральным репозиторием. Вы создаете ветку,

00:05:50.980 --> 00:05:54.360
Думайте об этом как о своей собственной копии книги, где можно вносить изменения,

00:05:54.520 --> 00:05:57.560
не затрагивая других. Вы пишете главу, тестируете ее и, когда будете готовы,

00:05:57.660 --> 00:06:01.540
создаете запрос на включение «Пулрекист». Это запрос на объединение ваших изменений с основной

00:06:01.540 --> 00:06:05.340
книгой. Другие авторы проверяют ваши изменения, оставляют комментарии и находят ошибки.

00:06:05.460 --> 00:06:08.940
Как только все одобрят, ваши изменения объединяются, и вся история отслеживается.

00:06:09.140 --> 00:06:13.400
Вы можете точно увидеть, кто изменил что, когда и почему. Вот почему новичкам стоит об этом знать.

00:06:13.600 --> 00:06:16.660
Больше никаких путанных имен файлов и сомнений, работаете ли вы над последней версией.

00:06:16.660 --> 00:06:20.480
Больше никакого случайного перезаписывания чужой работы. Гид предоставляет вам страховочную

00:06:20.480 --> 00:06:23.860
сетку. Вы можете экспериментировать, совершать ошибки и откатываться, если что-то сломалось.

00:06:24.000 --> 00:06:28.180
Это как кнопка «Отмена» для всего вашего проекта. И здесь появляется связь с Boards.

00:06:28.380 --> 00:06:32.740
Вы можете привязывать свои коммиты и пулреквесты напрямую к рабочим задачам. Когда разработчик

00:06:32.740 --> 00:06:37.420
исправляет баг, он добавляет ID бага в сообщение коммита, и этот коммит связывается с задачей в Boards.

00:06:37.640 --> 00:06:41.800
Внезапно вы получаете полную прослеживаемость. Вы можете точно увидеть, какие изменения кода были

00:06:41.800 --> 00:06:45.740
сделаны для каждой функции или исправления. Менеджеры по продукту могут нажать на задачу и увидеть

00:06:45.740 --> 00:06:48.760
реальный написанный код. Разработчики могут посмотреть на коммит и увидеть, к какой

00:06:48.760 --> 00:06:52.500
пользовательской истории он относится. Все взаимосвязано. Итак, теперь ваш код сохранен и

00:06:52.500 --> 00:06:56.560
отслеживается. Он в безопасности. У него есть версионность, но он просто лежит там. Как же

00:06:56.560 --> 00:07:00.340
сделать так, чтобы он заработал? Как превратить этот код в работающие приложения, которым могут

00:07:00.340 --> 00:07:05.180
пользоваться люди? Здесь на помощь приходит Azure Pipelines. Azure Pipelines — это движок автоматизации.

00:07:05.320 --> 00:07:08.400
Azure Pipelines — это движок автоматизации, который автоматически собирает,

00:07:08.560 --> 00:07:12.380
тестирует и развертывает ваш код. Проще говоря, он берет ваш код и превращает его в работающие

00:07:12.380 --> 00:07:15.480
приложения, избавляя вас от ручной работы. Представьте себе пекарню.

00:07:15.480 --> 00:07:19.380
Представьте, что у вас пекарня, и вы печете каждую буханку хлеба вручную для каждого заказа

00:07:19.380 --> 00:07:23.640
клиента. Именно так выглядит ручное развертывание. Кто-то пишет код, вы вручную копируете его на

00:07:23.640 --> 00:07:27.140
сервер, вручную запускаете сборку и вручную проверяете, работает ли он. Это медленно,

00:07:27.320 --> 00:07:31.520
чревато ошибками, и если заказов много, вы просто не успеваете. Здесь на помощь приходит

00:07:31.520 --> 00:07:36.180
Azure Pipelines. Вы автоматизируете весь процесс. Вы настраиваете его один раз, и он запускается

00:07:36.180 --> 00:07:40.560
автоматически каждый раз, когда кто-то меняет код. Это называется CI, CD — непрерывная

00:07:40.560 --> 00:07:44.400
интеграция и непрерывная доставка. Вот что означает непрерывная интеграция.

00:07:44.400 --> 00:07:48.860
Каждый раз, когда разработчик отправляет код в репозиторий, конвейер автоматически собирает

00:07:48.860 --> 00:07:53.280
приложение и запускает тесты. Если что-то ломается, вы узнаете об этом сразу, а не через две

00:07:53.280 --> 00:07:57.520
недели при попытке развертывания, немедленно. Разработчик получает уведомления, исправляет ошибку

00:07:57.520 --> 00:08:01.140
и отправляет код снова. Ошибки лучше находить на ранних этапах, пока их дешево исправлять,

00:08:01.260 --> 00:08:05.240
а не позже, когда это стоит дорого. Непрерывная доставка означает, что собранный и протестированный

00:08:05.240 --> 00:08:09.640
код автоматически разворачивается в ваших средах. Сначала в тестовую среду для проверки отделом QA,

00:08:09.640 --> 00:08:13.800
затем на стейджинг для финальной проверки, а после — в продакшн, где его увидят пользователи.

00:08:13.960 --> 00:08:17.540
На каждом этапе можно настроить встроенные согласования. Например, менеджер может потребоваться

00:08:17.540 --> 00:08:20.660
для утверждения развертывания в продакшн, а ведущему специалисту QA — для подтверждения

00:08:20.660 --> 00:08:22.820
результатов тестирования. Конвейер берет все это на себя.

00:08:23.020 --> 00:08:27.140
Давайте разберем ключевые функции. У вас есть YAML-файлы, етапы, согласования и агенты.

00:08:27.300 --> 00:08:31.560
YAML — это простой текстовый файл, в котором вы определяете свой конвейер. Он хранится в репозитории

00:08:31.560 --> 00:08:35.560
вместе с кодом, а значит, версионируется так же, как и ваш код. Вы всегда видите,

00:08:35.560 --> 00:08:40.020
кто, когда и зачем внес изменения. Етапы позволяют разбить конвейер на логические части.

00:08:40.220 --> 00:08:43.700
Сборка, тестирование, развертывание. Согласования позволяют ограничить развертывание,

00:08:43.860 --> 00:08:46.800
чтобы только авторизованные лица могли вносить изменения в продакшн. Агенты — это машины,

00:08:46.920 --> 00:08:50.100
которые непосредственно выполняют ваши сборки. Microsoft предоставляет облачные агенты,

00:08:50.240 --> 00:08:54.180
но вы можете использовать и свои собственные. Почему это важно для новичков? Потому что ручное

00:08:54.180 --> 00:08:59.240
развертывание — главная причина сбоев в продакшне. Кто-то забыл шаг, кто-то скопировал не тот файл,

00:08:59.440 --> 00:09:04.000
кто-то развернул не в ту среду. Конвейеры исключают все это. Они каждый раз работают одинаково.

00:09:04.000 --> 00:09:07.060
Никаких ошибок из-за человеческого фактора, никаких пропущенных шагов, и все это быстро.

00:09:07.200 --> 00:09:11.120
Одна команда, о которой я читал, сократила время ручного развертывания с нескольких часов до 10-15

00:09:11.120 --> 00:09:14.940
минут после внедрения Azure Pipelines. Это не просто небольшое улучшение. Это настоящая

00:09:14.940 --> 00:09:19.300
трансформация. Итак, ваш код собран, протестирован и развернут. Но прежде чем отправлять его клиентам,

00:09:19.440 --> 00:09:23.400
нужно убедиться, что он действительно работает. Не просто компилируется, а выполняет то, что должен.

00:09:23.560 --> 00:09:29.000
И здесь на помощь приходит Azure Test Plans. Azure Test Plans — качество без догадок. Ваш код собирается и

00:09:29.000 --> 00:09:33.160
разворачивается, но работает ли он на самом деле? Не только на вашей машине и не только в идеальных

00:09:33.160 --> 00:09:37.720
условиях. Работает ли он, если кто-то ввел неверные данные, если сеть тормозит или если тысячи

00:09:37.720 --> 00:09:41.060
человек пользуются им одновременно? Именно для этого и нужен Azure Test Plans.

00:09:41.200 --> 00:09:44.620
Test Plans — это структурированный подход к ручному и исследовательскому тестированию.

00:09:44.780 --> 00:09:48.580
Представьте это как предполетный контрольный список пилота. Пилоты не просто садятся в самолет

00:09:48.580 --> 00:09:52.920
в надежде на лучшее. У них есть чек-лист, проверка закрылков, топлива, приборов каждый раз,

00:09:53.100 --> 00:09:56.800
ведь пропуск одного пункта может привести к катастрофе. С программным обеспечением то же самое.

00:09:57.000 --> 00:09:59.780
Ошибка в продакшене может стоить вам денег, клиентов и репутации.

00:09:59.780 --> 00:10:04.240
Test Plans дает вам этот контрольный список. Вот как это работает. Вы создаете тест-кейсы.

00:10:04.380 --> 00:10:08.400
Каждый тест-кейс описывает конкретную задачу для проверки. Войти с действительным именем

00:10:08.400 --> 00:10:12.940
пользователя и паролем. Попробовать войти с неверным паролем. Попробовать отправить форму,

00:10:13.140 --> 00:10:17.440
не заполнив обязательные поля. У каждого тест-кейса есть шаги выполнения и ожидаемые

00:10:17.440 --> 00:10:21.980
результаты. Тестировщик проходит эти шаги, отмечая каждый как пройденный или проваленный.

00:10:22.140 --> 00:10:27.180
Если тест не пройден, можно создать баг прямо из тест-кейса. Этот баг создается как задача в

00:10:27.180 --> 00:10:31.940
Bords, назначается разработчику и связывается с тестом для полной очлеживаемости. Вы можете

00:10:31.940 --> 00:10:36.840
группировать тест-кейсы в наборы тестов. Например, набор для процесса оплаты, для регистрации

00:10:36.840 --> 00:10:40.720
пользователей или для панели администратора. Затем вы организуете эти наборы в планы

00:10:40.720 --> 00:10:44.400
тестирования для разных релизов или спринтов. Вы точно видите, что было протестировано,

00:10:44.560 --> 00:10:49.180
что пройдено, что провалено, а что еще не проверено. Связь с Bords — это то, что делает систему мощной.

00:10:49.180 --> 00:10:52.960
Когда тест провален, в Bords автоматически создается баг. Разработчик видит его,

00:10:53.100 --> 00:10:56.200
исправляет, отправляет фикс, а конвейер собирает и развертывает новую версию.

00:10:56.200 --> 00:11:00.800
Тестировщик запускает тест снова. Он пройден. Баг закрывается. Все это происходит в рамках

00:11:00.800 --> 00:11:04.240
одной платформы. Никаких таблиц по почте или переноса отчетов об ошибках между системами.

00:11:04.380 --> 00:11:08.580
Все взаимосвязано. Буду с вами откровенен. Новички часто упускают из виду тест-плэнс.

00:11:08.740 --> 00:11:13.140
Тестирование кажется лишней работой. Вам просто хочется выпустить свой код. Хочется увидеть его в деле.

00:11:13.320 --> 00:11:17.020
Но вот в чем дело. У каждого разработчика, с кем я общался, есть история об ошибке,

00:11:17.020 --> 00:11:21.400
которая попала в продакшн и привела к катастрофе. Платежная система, списавшая деньги дважды.

00:11:21.400 --> 00:11:25.400
Страница входа, которая упала под нагрузкой. Функция, которая удаляла данные вместо того,

00:11:25.560 --> 00:11:29.080
чтобы сохранять их. Такие ошибки — это всегда то, что можно было поймать простым тестом.

00:11:29.200 --> 00:11:32.420
Тест-плэнс — это дешевая страховка. Это требует немного времени в начале,

00:11:32.600 --> 00:11:36.000
но спасает от больших проблем в будущем. По мере роста команды вы столкнетесь с другой

00:11:36.000 --> 00:11:39.920
проблемой. Вы начнете писать один и тот же код снова и снова. Вспомогательные функции,

00:11:40.100 --> 00:11:43.400
компоненты логирования, апи-обертки. Вы будете копировать код между проектами,

00:11:43.400 --> 00:11:47.100
и вскоре у вас будет пять разных версий одного и того же, все немного отличаются и потенциально

00:11:47.100 --> 00:11:50.720
содержат ошибки. Вот здесь на помощь приходит Azure Artifacts. Azure Artifacts

00:11:50.720 --> 00:11:54.780
позволяет делиться вашими рабочими компонентами. Azure Artifacts — это менеджер пакетов для ваших

00:11:54.780 --> 00:11:58.360
библиотек кода, и проще всего представить его в виде деталей L и G.O. Вместо того,

00:11:58.480 --> 00:12:02.240
чтобы каждый раз создавать все с нуля, вы берете готовые блоки и соединяете их вместе.

00:12:02.440 --> 00:12:05.820
Когда кто-то в вашей команде создает библиотеку логирования, он публикует ее в Artifacts,

00:12:05.960 --> 00:12:08.720
после чего все остальные могут добавить ее в свои проекты одной строкой кода.

00:12:08.880 --> 00:12:13.120
Никакого копирования файлов, пересылки цип архивов по почте и гадания. Какая версия самая новая?

00:12:13.120 --> 00:12:17.780
Давайте разберем аналогию с L и G.O. подробнее. Представьте, что вы строите замок. Вы можете

00:12:17.780 --> 00:12:22.140
вырезать каждый кирпичик вручную, это как писать все с нуля, или же взять готовые кирпичи и

00:12:22.140 --> 00:12:26.580
сосредоточиться на уникальных деталях замка. Именно так работает Artifacts. Кирпичи — это ваши

00:12:26.580 --> 00:12:30.920
общие библиотеки, замок — это ваше приложение. Вам по-прежнему нужно создавать уникальные части,

00:12:31.160 --> 00:12:35.560
но нет нужды каждый раз изобретать велосипед. Artifacts поддерживает множество типов пакетов,

00:12:35.720 --> 00:12:41.180
NuJet — для NET, NPM — для JavaScript, Maven — для Java, пакеты Python и универсальные пакеты

00:12:41.180 --> 00:12:44.860
для всего остального. Вы создаете фид — это ваш приватный репозиторий пакетов,

00:12:45.040 --> 00:12:48.140
и публикуете в него свои пакеты. Вы настраиваете восходящие источники,

00:12:48.340 --> 00:12:52.960
чтобы также получать публичные пакеты из NuJet.org или npmjs.com через тот же самый фид.

00:12:53.060 --> 00:12:57.540
Все в одном месте. Почему это важно? Это экономит время, обеспечивает согласованность и позволяет

00:12:57.540 --> 00:13:00.960
управлять версиями. Когда вы обновляете общую библиотеку, вы публикуете новую версию,

00:13:01.040 --> 00:13:04.680
и проекты, использующие ее, могут обновиться, когда будут готовы. Вас не заставляют обновляться,

00:13:04.780 --> 00:13:07.840
и вы не застреваете на старой версии только потому, что никто не может найти последнюю копию.

00:13:07.840 --> 00:13:11.420
Все под контролем и организовано. И это напрямую подключается к конвейерам.

00:13:11.580 --> 00:13:14.880
Ваш конвейер сборки может автоматически публиковать пакеты в артефактс,

00:13:15.020 --> 00:13:18.460
а конвейер развертывания — использовать их, так что весь процесс автоматизирован.

00:13:18.640 --> 00:13:23.360
Код собирается, тестируется, упаковывается, публикуется и используется без необходимости

00:13:23.360 --> 00:13:26.900
вручную копировать файлы. Итак, теперь вы увидели все пять сервисов.

00:13:27.040 --> 00:13:29.860
Бордс для планирования, репост для кода, пайплайнс для автоматизации,

00:13:30.020 --> 00:13:33.800
тест плэнс для контроля качества и артефакт для обмена. Но настоящая магия заключается

00:13:33.800 --> 00:13:38.040
не в каждом отдельном сервисе, а в том, как они работают вместе. Позвольте показать вам,

00:13:38.240 --> 00:13:41.940
как это выглядит на практике. Общая картина, как все это складывается воедино.

00:13:42.100 --> 00:13:45.280
Позвольте показать, как это выглядит на практике на примере реального сценария,

00:13:45.500 --> 00:13:49.500
где команда создает новую функциональность. Шаг первый. Владелец продукта открывает

00:13:49.500 --> 00:13:53.440
Azure Boards и создает пользовательскую историю, например, как клиент. Я хочу иметь

00:13:53.440 --> 00:13:57.820
возможность сбросить пароль. Добавьте критерии приемки, назначьте задачу на текущий спринт,

00:13:57.880 --> 00:14:02.220
установите приоритет и рабочий элемент создан в системе. Шаг второй. Разработчик открывает

00:14:02.220 --> 00:14:06.020
Azure Repos, подтягивает актуальный код и создает новую ветку из рабочего элемента.

00:14:06.220 --> 00:14:10.020
Boards позволяет сделать это прямо из пользовательской истории. В имя ветки автоматически

00:14:10.020 --> 00:14:14.720
добавляется ID рабочего элемента. Разработчик пишет код, фиксирует его, а в сообщении коммита

00:14:14.720 --> 00:14:19.900
указывает Fixes 142. Это номер рабочего элемента. Теперь коммит связан с пользовательской историей

00:14:19.900 --> 00:14:24.680
в Boards. Шаг третий. Коммит автоматически запускает Azure Pipelines. Конвейер подхватывает код,

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

00:14:29.460 --> 00:14:33.640
конвейер останавливается, а разработчик получает уведомления. Если все прошло успешно,

00:14:33.780 --> 00:14:37.620
конвейер развертывает код в тестовой среде, и разработчик видит его работу до того,

00:14:37.780 --> 00:14:42.780
как его увидит кто-то другой. Шаг четвертый. Кьюи-инженер открывает Azure Test Plans,

00:14:43.040 --> 00:14:48.580
находит набор тестов для сброса пароля, выполняет ручные тесты, следует инструкциям и проверяет

00:14:48.580 --> 00:14:54.720
работу функции. Но он находит ошибку. Сообщение об ошибке опечатка. Инженер нажимает «Создать ошибку» прямо

00:14:54.720 --> 00:14:58.540
из тест-кейса, и в Boards появляется новый рабочий элемент, связанный с исходной историей.

00:14:58.540 --> 00:15:03.040
Разработчик видит его, исправляет, отправляет код. Конвейер запускается снова. Тестер повторяет

00:15:03.040 --> 00:15:07.780
тест, и все проходит успешно. Шаг пятый. Функция готова, и команда публикует общую библиотеку

00:15:07.780 --> 00:15:12.020
аутентификации в Azure Artifacts. Теперь другие команды могут использовать ее в своих проектах.

00:15:12.160 --> 00:15:15.640
Компонент сброса пароля доступен как пакет, поэтому любая команда, создающая новую функцию

00:15:15.640 --> 00:15:19.580
с аутентификацией, может добавить его одной строкой кода. Никакого переписывания или копирования,

00:15:19.760 --> 00:15:24.180
только ссылка. Это и есть связная разработка в действии. Каждый сервис — это отдельная комната.

00:15:24.180 --> 00:15:29.720
Boards — это зал планирования, репос, библиотека кода, пайплайнес, цех, тест-плэнс,

00:15:29.880 --> 00:15:35.080
станция контроля качества, а артефактс — склад. Но настоящая сила не в какой-то одной комнате.

00:15:35.280 --> 00:15:39.400
Она в коридорах, которые их соединяют. Рабочий элемент связан с кодом. Код запускает

00:15:39.400 --> 00:15:43.600
конвейер. Конвейер деплоит в тест. Тест создает ошибки в Boards, а готовый пакет отправляется

00:15:43.600 --> 00:15:47.640
в артефактс. Все взаимодействует со всем. И вот здесь начинается самое интересное.

00:15:47.640 --> 00:15:53.620
И приходит в Azure DevOps. Microsoft уже внедряет интеграции Copilot, такие как помощник по работе с

00:15:53.620 --> 00:15:58.640
элементами для написания лучших историй и для суммаризации длинных обсуждений и автоматический

00:15:58.640 --> 00:16:03.840
обзор кода в пулл-реквестах. Это только начало, но вектор развития ясен. Azure DevOps становится

00:16:03.840 --> 00:16:08.020
интеллектуальной платформой, а не просто набором инструментов. С чего же лучше всего начать?

00:16:08.180 --> 00:16:13.400
Вам не нужно внедрять все пять сервисов сразу. Выберите один. Начните с Boards, создайте проект,

00:16:13.400 --> 00:16:18.260
очледите несколько задач и оцените работу. Затем, когда будете готовы, добавьте Repos,

00:16:18.420 --> 00:16:23.780
после, Pipelines, шаг за шагом. Ваш первый шаг. Итак, основная идея вот в чем. Azure DevOps — это

00:16:23.780 --> 00:16:28.560
не пять разных инструментов, а одна связанная платформа. Boards, Repos, Pipelines, Test Plans и

00:16:28.560 --> 00:16:32.440
артефактс работают вместе. Ценность не в каждом элементе по отдельности, а в их взаимодействии.

00:16:32.620 --> 00:16:37.460
Вот ваш первый шаг. Перейдите на dev.azur.com и создайте бесплатную учетную запись. Затем создайте

00:16:37.460 --> 00:16:41.400
новый проект. Изучите boards, создайте пользовательскую историю, переместите ее по доске Kanban и

00:16:41.400 --> 00:16:45.680
посмотрите, как это работает. Ваша задача. Выберите один небольшой проект. Подойдет что угодно.

00:16:45.860 --> 00:16:49.300
Очлеживайте его в boards в течение недели, добавляйте задачи, обновляйте статусы и почувствуйте,

00:16:49.500 --> 00:16:53.220
каково это иметь прозрачную и организованную работу. В следующем эпизоде мы погрузимся в Azure

00:16:53.220 --> 00:16:58.520
Pipelines. Мы шаг за шагом создадим ваш первый CI, CD-конвейер и увидим, как автоматизировать сборку и

00:16:58.520 --> 00:17:02.900
развертывание с нуля. Подписывайтесь на любимой платформе подкастов и поделитесь этим выпуском с теми,

00:17:02.900 --> 00:17:04.260
кто начинает свой путь в DevOps.
