WEBVTT

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

00:00:03.960 --> 00:00:08.960
MCP. Вы, вероятно, видели, как его называют HTTP для E-агентов, но что это означает на самом деле?

00:00:09.120 --> 00:00:15.520
К концу этого выпуска вы поймете, что такое MCP, что делает сервер Azure MCP и почему это важно для подключения E-инструментов к вашим данным.

00:00:15.680 --> 00:00:23.680
Мы разберем это по основным компонентам, начав с общей картины, затем перейдем к самому протоколу реализации от Microsoft и, наконец, к реальному примеру, который вы сможете использовать.

00:00:23.840 --> 00:00:25.900
Общая картина. Почему это важно сейчас?

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

00:00:33.840 --> 00:00:39.400
Все они пытаются создать и помощников, которые действительно способны что-то делать. Не просто отвечать на вопросы, а предпринимать реальные действия.

00:00:39.560 --> 00:00:43.180
Обновлять записи, проверять инвентарь, развертывать код или чинить сломанный сервер.

00:00:43.300 --> 00:00:48.100
И вот здесь возникает проблема. Этим агентам нужно подключаться к реальным инструментам и реальным данным.

00:00:48.280 --> 00:00:51.800
Базам данных, хранилищам, системам тикетов, CRM-платформам.

00:00:51.800 --> 00:00:58.580
Большинство людей сегодня делают это сложным путем. Они пишут кастомный код интеграции для каждого отдельного инструмента, каждого API, каждого источника данных.

00:00:58.760 --> 00:01:02.580
Один коннектор для базы данных, другой для хранилища файлов, третий для системы мониторинга.

00:01:02.760 --> 00:01:08.080
Каждый требует своей аутентификации, обработки ошибок, своего способа форматирования запросов и ответов.

00:01:08.220 --> 00:01:10.800
Этот подход хрупок, трудоемок и не масштабируется.

00:01:11.020 --> 00:01:15.720
Каждому создаваемому и помощнику нужна своя куча склеивающего кода для взаимодействия с нужными сервисами.

00:01:15.860 --> 00:01:19.100
Переходите с одной и платформы на другую и переделываете все с нуля.

00:01:19.280 --> 00:01:22.400
Большинство демоверсий и, которые вы видите, отлично работают в изоляции.

00:01:22.580 --> 00:01:27.760
Они отвечают на вопросы, генерируют текст, выглядят впечатляюще, но как только им нужно коснуться реальной системы, они ломаются.

00:01:27.960 --> 00:01:29.340
Вот где скрывается сложность.

00:01:29.500 --> 00:01:30.500
MCP меняет это.

00:01:30.640 --> 00:01:33.740
Он дает и стандартный способ обращаться к нужным ресурсам и получать их.

00:01:33.820 --> 00:01:36.340
Один протокол, один способ взаимодействия с инструментами.

00:01:36.540 --> 00:01:40.240
Любой и помощник, поддерживающий MCP, может использовать любой MCP-сервер.

00:01:40.240 --> 00:01:46.580
Это как разница между наличием отдельного пульта для каждого устройства в доме и одним универсальным пультом, который работает совсем сразу.

00:01:46.740 --> 00:01:48.940
Итак, начнем с самого простого определения.

00:01:49.140 --> 00:01:51.060
Что такое MCP-объяснение протокола?

00:01:51.240 --> 00:01:52.820
Что именно представляет собой MCP?

00:01:52.940 --> 00:01:54.460
Позвольте объяснить простыми словами.

00:01:54.580 --> 00:01:56.640
MCP расшифровывается как модел-контекст-протокол.

00:01:56.800 --> 00:02:01.560
Это открытый стандарт, который определяет, как и агенты взаимодействуют с внешними инструментами, API и источниками данных.

00:02:01.740 --> 00:02:03.600
Думайте об этом как об общем языке для ИИ.

00:02:03.740 --> 00:02:08.780
До появления MCP каждому ИИ-помощнику приходилось изучать отдельный язык для каждого инструмента, который он хотел использовать.

00:02:08.780 --> 00:02:13.780
MCP предлагает «давайте договоримся об одном языке», и тогда каждому инструменту нужно будет знать только его.

00:02:13.900 --> 00:02:16.720
По сути, в его основе лежит JSON-RPC 2.0.

00:02:16.920 --> 00:02:19.740
Простой формат сообщений для отправки запросов и получения ответов.

00:02:19.840 --> 00:02:22.400
Ничего сложного, этот стандарт существует уже много лет.

00:02:22.540 --> 00:02:24.220
MCP добавляет к этому структуру.

00:02:24.340 --> 00:02:29.680
Он определяет три ключевые вещи, которые и агент может делать с любым MCP-сервером – инструменты, ресурсы и промпты.

00:02:29.860 --> 00:02:33.960
Инструменты – это действия, которые может выполнять ИИ, например, создание записи или запуск запроса.

00:02:33.960 --> 00:02:38.280
Ресурсы – это данные, которые ИИ может считывать, например, профиль клиента или файл журнала.

00:02:38.400 --> 00:02:42.400
А промпты – это шаблоны, которые определяют, как ИИ должен вести себя в определенных ситуациях.

00:02:42.520 --> 00:02:44.000
Вот самый простой способ это понять.

00:02:44.140 --> 00:02:46.500
Представьте, что у вас есть универсальный пульт дистанционного управления.

00:02:46.680 --> 00:02:49.680
Этот пульт может взаимодействовать с вашим телевизором, аудиосистемой, ТВ-приставкой и освещением.

00:02:49.820 --> 00:02:51.300
Один пульт – множество устройств.

00:02:51.420 --> 00:02:53.320
MCP – это такой пульт для ИИ-агентов.

00:02:53.460 --> 00:02:55.180
Один протокол – множество инструментов.

00:02:55.180 --> 00:03:00.620
Вы создаете один MCP-сервер, который открывает доступ к вашим инструментам и данным, и любой ИИ-агент с поддержкой MCP может его использовать.

00:03:00.820 --> 00:03:05.340
GitHub, Copilot, Cloud, ChatGPT, пользовательские агенты – все они говорят на одном протоколе.

00:03:05.420 --> 00:03:07.200
И это незакрытая разработка Microsoft.

00:03:07.500 --> 00:03:13.800
MCP был изначально создан компанией Anthropic, разработчиком Cloud, но его приняли OpenAI, Google, Microsoft и многие другие.

00:03:14.000 --> 00:03:17.480
Он становится стандартным способом подключения ИИ-агентов к внешнему миру.

00:03:17.600 --> 00:03:21.040
Это не привязка к поставщику, а открытый стандарт, которым может пользоваться каждый.

00:03:21.220 --> 00:03:23.000
Проблема, которую решает MCP.

00:03:23.000 --> 00:03:27.620
Вот как это делалось раньше. До появления MCP каждая интеграция ИИ была отдельным проектом.

00:03:27.780 --> 00:03:31.200
Допустим, вы хотите, чтобы ваш ИИ-помощник проверял уровень запасов в базе данных.

00:03:31.340 --> 00:03:33.100
Отлично. Теперь нужно писать код.

00:03:33.280 --> 00:03:34.840
Нужно разобраться с аутентификацией.

00:03:34.960 --> 00:03:37.280
Как ИИ докажет, что ему разрешено читать эти данные.

00:03:37.520 --> 00:03:38.660
Нужно обрабатывать ошибки.

00:03:38.840 --> 00:03:41.000
Что произойдет, если база данных недоступна?

00:03:41.140 --> 00:03:42.360
Нужно отформатировать ответ.

00:03:42.540 --> 00:03:44.200
Как превратить данные из базы в то?

00:03:44.380 --> 00:03:45.500
Что сможет понять ИИ?

00:03:45.640 --> 00:03:48.560
Неделя разработки ради одного подключения к одной базе данных.

00:03:48.680 --> 00:03:49.900
Это налог на интеграцию.

00:03:49.900 --> 00:03:52.700
Один ИИ-помощник, одна база данных, неделя работы.

00:03:52.840 --> 00:03:55.840
А теперь умножьте это на каждый инструмент, с которым должен работать ваш ИИ.

00:03:55.960 --> 00:03:59.340
CRM, система обработки заявок, файловое хранилище, журналы мониторинга.

00:03:59.520 --> 00:04:02.900
Для каждого требуется свой код, свой метод аутентификации, своя обработка ошибок.

00:04:02.980 --> 00:04:05.440
И ни один из этих фрагментов кода не работает с другими инструментами.

00:04:05.580 --> 00:04:08.720
Вы строите одно и то же снова и снова, каждый раз лишь немного меняя детали.

00:04:08.840 --> 00:04:10.720
И вот в чем заключается проблема безопасности.

00:04:10.820 --> 00:04:13.520
У каждой пользовательской интеграции своя собственная аутентификация.

00:04:13.740 --> 00:04:17.720
Где-то используются API-ключи, где-то OAT, сертификаты или базовая аутентификация.

00:04:17.720 --> 00:04:22.720
В итоге вы получаете десяток разных способов работы с данными ИИ, но нет единого механизма управления ими.

00:04:22.840 --> 00:04:26.120
У кого есть доступ? Что они могут делать? Где находятся логи?

00:04:26.280 --> 00:04:30.100
Большинство организаций не могут ответить на эти вопросы по своим ИИ-интеграциям,

00:04:30.220 --> 00:04:33.820
потому что они создавались разными командами в разное время и по разным стандартам.

00:04:33.960 --> 00:04:35.800
Проблема фрагментации – это реальность.

00:04:36.000 --> 00:04:38.720
Допустим, вы создаете своего ИИ-помощника на базе OpenAI.

00:04:38.920 --> 00:04:41.780
Вы пишете все свои интеграции под формат вызова функции OpenAI.

00:04:42.020 --> 00:04:45.820
Затем, через 6 месяцев, ваша компания решает перейти на Клод или вы хотите использовать оба.

00:04:45.820 --> 00:04:48.000
Теперь вам приходится переделывать каждую интеграцию заново.

00:04:48.080 --> 00:04:50.000
Те же инструменты, те же данные, другой формат.

00:04:50.100 --> 00:04:51.760
Это не прогресс, это пустая трата времени.

00:04:51.980 --> 00:04:53.320
Реальные расходы быстро растут.

00:04:53.480 --> 00:04:56.280
Большинство крупных организаций уже используют десятки ИИ-агентов.

00:04:56.420 --> 00:04:59.480
По данным IDC, в среднем предприятие использует их 47 штук.

00:04:59.600 --> 00:05:01.980
У каждого из них своя куча пользовательских коннекторов.

00:05:02.040 --> 00:05:04.060
И вот статистика, которая может вас удивить.

00:05:04.160 --> 00:05:07.940
68% ИИ-директоров даже не могут назвать общие расходы на ИИ-агентов.

00:05:08.100 --> 00:05:10.020
Они не знают, сколько тратят на эти интеграции,

00:05:10.220 --> 00:05:12.980
потому что расходы разбросаны по разным командам, проектам и бюджетам.

00:05:12.980 --> 00:05:14.780
MCP полностью меняет эту модель.

00:05:14.960 --> 00:05:18.600
Вместо написания кода под каждый ИИ-инструмент вы создаете один MCP-сервер.

00:05:18.740 --> 00:05:22.000
Этот сервер предоставляет доступ к вашим инструментам и данным через стандартный интерфейс.

00:05:22.160 --> 00:05:24.560
Затем его может использовать любой агент, совместимый с MCP.

00:05:24.680 --> 00:05:28.040
Copilot, Cloud, ChatGPT, пользовательские агенты, ваши собственные внутренние инструменты.

00:05:28.160 --> 00:05:29.720
Напишите один раз, используйте везде.

00:05:29.880 --> 00:05:31.060
В этом и заключается переход.

00:05:31.280 --> 00:05:32.600
Что такое Azure MCP-сервер?

00:05:32.740 --> 00:05:34.920
Итак, мы разобрались с проблемой, которую решает MCP.

00:05:35.040 --> 00:05:37.060
Теперь давайте поговорим об ответе Microsoft на нее.

00:05:37.220 --> 00:05:40.260
Azure MCP-сервер – это официальный взгляд Microsoft на MCP.

00:05:40.260 --> 00:05:45.240
Представьте его как мост, который позволяет ИИ-агентам безопасно обращаться к вашим ресурсам Azure и управлять ими.

00:05:45.340 --> 00:05:47.560
И я хочу прояснить, что это такое на самом деле.

00:05:47.700 --> 00:05:49.640
Это не отдельный продукт, который нужно покупать.

00:05:49.780 --> 00:05:50.900
Это не новая служба Azure.

00:05:51.080 --> 00:05:55.240
Это инструмент – сервер с открытым исходным кодом, который находится между вашим ИИ-помощником и средой Azure.

00:05:55.380 --> 00:05:57.380
Он работает с режимом агента в GitHub Copilot.

00:05:57.540 --> 00:05:58.860
Он работает с Semantic Kernel.

00:05:58.980 --> 00:06:00.140
Он работает с Cloud Desktop.

00:06:00.300 --> 00:06:03.200
И он работает с любым пользовательским MCP-агентом, который вы создадите сами.

00:06:03.200 --> 00:06:06.060
Любой клиент, поддерживающий протокол MCP, может к нему подключиться.

00:06:06.060 --> 00:06:10.140
После подключения агент получает доступ к вашим ресурсам Azure с помощью обычного естественного языка.

00:06:10.280 --> 00:06:11.880
Вам не нужно знать точный вызов API.

00:06:12.100 --> 00:06:13.680
Вам не нужно помнить метод SDK.

00:06:13.980 --> 00:06:15.020
Вы просто спрашиваете.

00:06:15.260 --> 00:06:16.280
Вот основная идея.

00:06:16.440 --> 00:06:20.860
В Azure десятки сервисов, хранилища, базы данных, мониторинг, конфигурации, контейнеры.

00:06:21.020 --> 00:06:24.760
У каждого свой SDK, свой API и свой собственный метод аутентификации.

00:06:24.920 --> 00:06:27.580
MCP-сервер Azure объединяет их все в единый интерфейс.

00:06:27.660 --> 00:06:29.960
Один сервер, один протокол, все инструменты сразу.

00:06:30.160 --> 00:06:31.640
Зачем Microsoft создала это?

00:06:31.780 --> 00:06:34.560
Потому что проблема фрагментации в Azure стоит особенно остро.

00:06:34.560 --> 00:06:38.460
Представьте, что вы создаете и агента, которому нужно проверить логи Azure Monitor,

00:06:38.700 --> 00:06:41.580
обновить настройки приложения и развернуть новую версию контейнера.

00:06:41.760 --> 00:06:46.780
Это три разных SDK, три разных потока аутентификации, три способа обработки ошибок.

00:06:46.920 --> 00:06:52.800
MCP-сервер Azure сводит все это к одной сессии, одной аутентификации и единому подходу к работе.

00:06:52.920 --> 00:06:54.140
А теперь самое важное.

00:06:54.300 --> 00:06:55.860
Это не только для разработчиков.

00:06:55.980 --> 00:06:57.740
Да, разработчики будут его использовать.

00:06:57.940 --> 00:07:01.700
Но главная сила в том, что он позволяет управлять ресурсами Azure на естественном языке.

00:07:01.700 --> 00:07:05.940
Тот, кто не знает PowerShell или Azure CLI, может попросить своего и ассистента,

00:07:06.180 --> 00:07:09.500
покажи ошибки платежного сервиса за последний час и получить ответ.

00:07:09.680 --> 00:07:11.960
MCP-сервер берет на себя перевод запроса.

00:07:12.080 --> 00:07:14.900
Он превращает запрос на естественном языке в нужный вызов API,

00:07:15.180 --> 00:07:17.660
выполняет его через Azure Monitor и возвращает результат.

00:07:17.820 --> 00:07:21.480
На сегодняшний день MCP-сервер Azure встроен в Visual Studio 2026.

00:07:21.720 --> 00:07:23.760
Он доступен с открытым исходным кодом на GitHub.

00:07:23.960 --> 00:07:26.480
Он активно поддерживается командой Azure SDK в Microsoft.

00:07:26.740 --> 00:07:29.900
Он находится в публичном доступе, а значит, вы можете использовать его прямо сейчас,

00:07:29.900 --> 00:07:31.440
и возможности постоянно расширяются.

00:07:31.620 --> 00:07:33.460
Основные сервисы, к которым есть доступ.

00:07:33.620 --> 00:07:36.200
Итак, что же на самом деле можно делать с помощью MCP-сервера Azure?

00:07:36.360 --> 00:07:38.600
Давайте посмотрим на конкретные сервисы, с которыми он работает.

00:07:38.820 --> 00:07:41.360
Список постоянно растет, но вот что поддерживается прямо сейчас.

00:07:41.520 --> 00:07:42.240
Azure Starage.

00:07:42.400 --> 00:07:44.060
Вы можете просматривать учетные записи хранения,

00:07:44.180 --> 00:07:46.080
управлять BLOB контейнерами и запрашивать таблицы,

00:07:46.200 --> 00:07:47.260
и все это на естественном языке.

00:07:47.420 --> 00:07:49.400
Вместо написания скрипта для проверки хранилища,

00:07:49.500 --> 00:07:50.340
вы просто спрашиваете,

00:07:50.460 --> 00:07:53.260
покажи мне контейнеры в моей производственной учетной записи хранения.

00:07:53.420 --> 00:07:57.300
MCP-сервер выполняет вызов API, форматирует ответ и дает вам результат.

00:07:57.300 --> 00:07:59.460
Azure Cosmos DB – это очень важно.

00:07:59.660 --> 00:08:01.000
Вы можете запрашивать базы данных,

00:08:01.160 --> 00:08:04.280
управлять контейнерами и выполнять SQL-запросы к вашим NoSQL-данным.

00:08:04.420 --> 00:08:05.600
Если вы создаете и агента,

00:08:05.760 --> 00:08:08.080
которому нужно искать записи клиентов или историю заказов,

00:08:08.240 --> 00:08:09.380
вот как он получит эти данные.

00:08:09.560 --> 00:08:11.720
Никаких пользовательских коннекторов или кода SDK,

00:08:12.040 --> 00:08:13.560
просто вызов инструмента через MCP.

00:08:13.660 --> 00:08:16.280
Azure Monitor – здесь проявляется настоящая мощь.

00:08:16.380 --> 00:08:18.340
Вы можете делать запросы к логам через KQL,

00:08:18.620 --> 00:08:19.600
язык запросов каста,

00:08:19.760 --> 00:08:21.860
не написав самостоятельно ни одной команды KQL.

00:08:22.060 --> 00:08:23.360
Перечислите рабочие области,

00:08:23.620 --> 00:08:24.840
проверьте доступные таблицы,

00:08:24.840 --> 00:08:27.720
попросите показать ошибки за последние 24 часа,

00:08:27.920 --> 00:08:29.940
и MCP-сервер преобразует это в нужный запрос,

00:08:30.160 --> 00:08:32.380
выполнит его в Log Analytics и вернет результаты.

00:08:32.460 --> 00:08:34.800
Для всех, кто когда-либо мучился с синтаксисом KQL,

00:08:35.080 --> 00:08:36.940
только ради этого стоит попробовать данное решение.

00:08:37.140 --> 00:08:38.940
Azure App Configuration позволяет управлять парами

00:08:38.940 --> 00:08:39.800
«ключ-значение»,

00:08:39.800 --> 00:08:40.960
настраивать параметры включения,

00:08:41.080 --> 00:08:42.580
блокировать и разблокировать конфигурации.

00:08:42.720 --> 00:08:45.000
Если ваше приложение считывает конфигурацию

00:08:45.000 --> 00:08:46.280
из Azure App Configuration,

00:08:46.480 --> 00:08:48.520
ваш и агент может проверять эти значения,

00:08:48.700 --> 00:08:50.460
обновлять их и подтверждать изменения,

00:08:50.640 --> 00:08:51.660
и все это через диалог.

00:08:51.660 --> 00:08:55.020
И это не только сервисы Azure CLI и Azure Developer CLI,

00:08:55.200 --> 00:08:57.200
AZD также представлены как инструменты.

00:08:57.300 --> 00:08:58.760
Это означает, что ваш и агент

00:08:58.760 --> 00:09:01.100
может напрямую выполнять любую команду Azure CLI.

00:09:01.220 --> 00:09:02.540
Он может подготавливать ресурсы,

00:09:02.720 --> 00:09:03.640
развертывать приложения,

00:09:03.820 --> 00:09:04.820
управлять инфраструктурой,

00:09:04.940 --> 00:09:05.680
все те же команды,

00:09:05.880 --> 00:09:06.860
что вы вводите в терминале,

00:09:07.020 --> 00:09:08.540
но запускаемые на естественном языке

00:09:08.540 --> 00:09:09.420
через e-помощника.

00:09:09.580 --> 00:09:10.960
На практике это означает,

00:09:11.180 --> 00:09:12.680
что один MCP может заменить

00:09:12.680 --> 00:09:14.540
десятки SDK и вызовов API.

00:09:14.740 --> 00:09:16.860
Вам не нужно устанавливать Azure Starage SDK,

00:09:17.120 --> 00:09:18.060
Cosmos DBSDK,

00:09:18.220 --> 00:09:18.880
Monitor SDK

00:09:18.880 --> 00:09:21.100
и изучать три разных способа аутентификации.

00:09:21.280 --> 00:09:22.680
Вы устанавливаете один MCP-сервер,

00:09:22.820 --> 00:09:24.120
проходите аутентификацию один раз,

00:09:24.300 --> 00:09:25.120
и все эти возможности

00:09:25.120 --> 00:09:26.700
становятся доступны через единый интерфейс.

00:09:26.800 --> 00:09:28.120
Подумайте о типичном сценарии

00:09:28.120 --> 00:09:29.200
устранения неполадок.

00:09:29.400 --> 00:09:30.920
Ваше приложение выдает ошибки.

00:09:31.120 --> 00:09:32.120
Вам нужно проверить журналы,

00:09:32.220 --> 00:09:33.120
посмотреть конфигурацию,

00:09:33.340 --> 00:09:34.100
убедиться в доступности

00:09:34.100 --> 00:09:35.080
учетной записи хранения

00:09:35.080 --> 00:09:36.560
и проверить подключение к базе данных.

00:09:36.720 --> 00:09:38.700
До появления MCP это четыре разных инструмента,

00:09:38.880 --> 00:09:39.900
четыре разных входа в систему,

00:09:40.100 --> 00:09:41.660
четыре разных способа получения информации.

00:09:41.660 --> 00:09:44.020
С сервером Azure MCP это один диалог.

00:09:44.140 --> 00:09:44.900
Покажи мне ошибки,

00:09:45.060 --> 00:09:46.020
проверь мою конфигурацию,

00:09:48.880 --> 00:09:50.240
сервер берет все это на себя.

00:09:50.380 --> 00:09:51.800
Как это работает на самом деле?

00:09:52.020 --> 00:09:53.480
Давайте заглянем под капот.

00:09:53.600 --> 00:09:55.040
Как это работает за кулисами?

00:09:55.520 --> 00:09:57.080
Аутентификация использует интро-айди,

00:09:57.320 --> 00:09:58.660
то есть ваш Azure Active Directory

00:09:58.660 --> 00:10:00.340
через библиотеку Azure Identity.

00:10:00.460 --> 00:10:01.840
Когда ваш и агент делает запрос,

00:10:01.980 --> 00:10:03.160
он проходит аутентификацию,

00:10:03.340 --> 00:10:04.780
используя вашу учетную запись Azure.

00:10:04.900 --> 00:10:05.620
Те же учетные данные,

00:10:05.740 --> 00:10:07.080
что вы используете для входа на портал Azure.

00:10:07.260 --> 00:10:08.220
Никаких отдельных API-ключей,

00:10:08.360 --> 00:10:09.680
никаких общих сервисных учетных записей,

00:10:09.800 --> 00:10:10.400
только ваша личность.

00:10:10.540 --> 00:10:12.200
Представьте это как стойку регистрации.

00:10:12.200 --> 00:10:13.560
Сервер проверяет ваша ID,

00:10:13.800 --> 00:10:14.760
прежде чем впустить вас.

00:10:14.760 --> 00:10:17.060
Авторизация соблюдает правила Azure RBAC,

00:10:17.320 --> 00:10:18.640
контроля доступа на основе ролей.

00:10:18.800 --> 00:10:21.380
MCP-сервер не предоставляет никаких новых разрешений.

00:10:21.520 --> 00:10:22.460
Он разрешает только то,

00:10:22.540 --> 00:10:24.380
на что у вашей учетной записи уже есть права.

00:10:24.500 --> 00:10:25.440
Если вы можете просматривать

00:10:25.440 --> 00:10:26.740
учетные записи хранения на портале,

00:10:26.920 --> 00:10:28.260
MCP-сервер тоже может их читать.

00:10:28.400 --> 00:10:29.680
Если вы не можете удалять базы данных,

00:10:29.820 --> 00:10:31.280
MCP-сервер тоже не сможет этого сделать.

00:10:31.420 --> 00:10:33.460
Он наследует существующую модель безопасности Azure.

00:10:33.640 --> 00:10:35.360
Он не создает новые поверхности для атак.

00:10:35.460 --> 00:10:36.860
Если вы уже доверяете Azure в вопросах

00:10:36.860 --> 00:10:37.720
запуска своих приложений,

00:10:37.720 --> 00:10:39.480
то можете доверять и этой модели безопасности.

00:10:39.640 --> 00:10:41.740
Для передачи данных предусмотрено два варианта.

00:10:41.740 --> 00:10:44.100
Потоковый HTTP для удаленных подключений,

00:10:44.220 --> 00:10:46.160
когда ваш и ассистент работает в облаке

00:10:46.160 --> 00:10:47.280
или на другом компьютере,

00:10:47.460 --> 00:10:49.120
и STDIO для локальной разработки,

00:10:49.280 --> 00:10:50.880
когда все запущено на вашей машине.

00:10:51.020 --> 00:10:53.680
Microsoft рекомендует для продакшена потоковый HTTP,

00:10:54.000 --> 00:10:55.080
так как он отлично работает

00:10:55.080 --> 00:10:57.340
с балансировщиками нагрузки и прокси-серверами.

00:10:57.460 --> 00:10:58.980
Представьте это как телефонный звонок

00:10:58.980 --> 00:10:59.900
для удаленной связи

00:10:59.900 --> 00:11:01.220
и личный разговор для локальной.

00:11:01.380 --> 00:11:02.400
Здесь важны сессии.

00:11:02.580 --> 00:11:04.380
MCP-сервер поддерживает состояние

00:11:04.380 --> 00:11:05.680
на протяжении всего диалога.

00:11:05.680 --> 00:11:07.560
Поэтому, когда ваш агент задает вопрос,

00:11:07.740 --> 00:11:09.460
получает ответ и затем уточняет его,

00:11:09.680 --> 00:11:11.340
сервер помнит, что происходило ранее.

00:11:11.540 --> 00:11:13.640
Инструменты могут опираться на предыдущие шаги.

00:11:13.780 --> 00:11:14.960
Вы можете запрашивать логи,

00:11:15.120 --> 00:11:15.840
находить проблему,

00:11:16.020 --> 00:11:17.840
создавать исправление и разворачивать его,

00:11:18.040 --> 00:11:19.080
все в рамках одной сессии,

00:11:19.260 --> 00:11:20.040
не теряя контекста.

00:11:20.180 --> 00:11:21.420
Это как беседа за чашкой кофе,

00:11:21.580 --> 00:11:22.720
где вы продолжаете с того места,

00:11:22.840 --> 00:11:23.640
на котором остановились.

00:11:23.840 --> 00:11:25.040
Сервер использует Azure SDK,

00:11:25.320 --> 00:11:27.040
а значит, наследует всю встроенную логику

00:11:27.040 --> 00:11:28.740
повторных попыток и обработки ошибок,

00:11:28.820 --> 00:11:29.840
которые они предоставляют.

00:11:29.920 --> 00:11:30.960
Если запрос не прошел

00:11:30.960 --> 00:11:32.440
из-за кратковременной сетевой ошибки,

00:11:32.620 --> 00:11:33.860
он повторяется автоматически.

00:11:33.860 --> 00:11:35.260
Если сервис недоступен,

00:11:35.440 --> 00:11:37.060
сервер корректно обрабатывает ошибку.

00:11:37.220 --> 00:11:38.860
Вам не нужно писать это самостоятельно.

00:11:39.020 --> 00:11:40.480
Все это уже включено в функционал.

00:11:40.640 --> 00:11:41.820
Модель безопасности использует

00:11:41.820 --> 00:11:43.640
метод аутентификации от имени пользователя

00:11:43.640 --> 00:11:44.260
или ОБИО.

00:11:44.360 --> 00:11:45.220
Это важный момент.

00:11:45.440 --> 00:11:47.180
Когда ваш и агент вызывает инструмент,

00:11:47.460 --> 00:11:48.600
MCP-сервер передает

00:11:48.600 --> 00:11:49.580
вашу учетную запись

00:11:49.580 --> 00:11:50.780
ниже стоящему сервису.

00:11:50.960 --> 00:11:52.760
Хранилище видит вашу учетную запись,

00:11:53.000 --> 00:11:53.960
а не личность сервера.

00:11:54.100 --> 00:11:55.160
База данных видит вас,

00:11:55.360 --> 00:11:56.220
а не какую-то общую

00:11:56.220 --> 00:11:57.440
сервисную учетную запись.

00:11:57.580 --> 00:11:58.140
Это означает,

00:11:58.140 --> 00:11:59.040
что каждое действие

00:11:59.040 --> 00:11:59.880
можно отследить до вас.

00:12:00.080 --> 00:12:01.160
В каждом журнале аудита видно,

00:12:01.380 --> 00:12:01.920
кто и что сделал.

00:12:02.120 --> 00:12:03.440
Никаких анонимных сервисных аккаунтов,

00:12:03.580 --> 00:12:04.640
чьи действия невозможно отследить.

00:12:04.820 --> 00:12:05.440
Сервер говорит,

00:12:05.600 --> 00:12:06.680
я здесь от имени мира.

00:12:06.800 --> 00:12:07.860
И сервис видит вас,

00:12:08.080 --> 00:12:08.600
а не сервер.

00:12:08.760 --> 00:12:09.280
Для компаний,

00:12:09.400 --> 00:12:11.100
которым требуется еще больше контроля,

00:12:11.280 --> 00:12:12.220
перед MCP-серверами

00:12:12.220 --> 00:12:12.920
можно поставить

00:12:12.920 --> 00:12:13.740
Azure API Management.

00:12:14.000 --> 00:12:15.120
Это дает политике управления,

00:12:15.300 --> 00:12:16.480
ограничение частоты запросов,

00:12:16.620 --> 00:12:17.220
журналы аудита

00:12:17.220 --> 00:12:18.520
и проверки безопасности контента

00:12:18.520 --> 00:12:19.220
на уровне протокола.

00:12:19.360 --> 00:12:20.240
Вы можете контролировать,

00:12:20.380 --> 00:12:21.460
какие инструменты доступны,

00:12:21.660 --> 00:12:22.480
кто может их использовать

00:12:22.480 --> 00:12:23.040
и как часто.

00:12:23.040 --> 00:12:24.160
Это тот же API Management,

00:12:24.420 --> 00:12:25.840
который вы используете для REST API,

00:12:26.080 --> 00:12:26.780
теперь применимый

00:12:26.780 --> 00:12:27.880
и к MCP-инструментам.

00:12:27.880 --> 00:12:28.940
Вот основной вывод.

00:12:29.140 --> 00:12:30.140
Azure MCP-сервер

00:12:30.140 --> 00:12:30.760
не придумывает

00:12:30.760 --> 00:12:32.240
новых механизмов безопасности.

00:12:32.400 --> 00:12:33.220
Он использует те,

00:12:33.420 --> 00:12:34.260
что уже есть в Azure.

00:12:34.400 --> 00:12:35.880
IntraID для аутентификации,

00:12:36.020 --> 00:12:37.240
RBC для авторизации,

00:12:37.400 --> 00:12:38.500
SDK для надежности,

00:12:38.700 --> 00:12:39.900
API Management для управления.

00:12:40.080 --> 00:12:41.100
Если вы уже доверяете Azure

00:12:41.100 --> 00:12:42.520
в вопросах запуска своих приложений,

00:12:42.600 --> 00:12:44.080
то можете доверять и модели безопасности,

00:12:44.200 --> 00:12:45.460
которую использует MCP-сервер.

00:12:45.560 --> 00:12:47.100
Пример из реальной жизни в действии.

00:12:47.260 --> 00:12:48.180
Давайте разберем ситуацию,

00:12:48.180 --> 00:12:49.760
с которой вы действительно можете столкнуться.

00:12:49.880 --> 00:12:50.300
Представьте,

00:12:50.440 --> 00:12:52.140
что вы запускаете контейнерное приложение в Azure.

00:12:52.280 --> 00:12:53.180
Вы переходите по ссылке

00:12:53.180 --> 00:12:54.560
и получаете ошибку 404.

00:12:54.700 --> 00:12:55.840
Приложение не запускается.

00:12:55.840 --> 00:12:57.500
Портал Azure показывает ошибку активации,

00:12:57.640 --> 00:12:58.320
но журналы пусты.

00:12:58.440 --> 00:12:59.600
Никакой полезной информации.

00:12:59.800 --> 00:13:00.300
Вы в тупике.

00:13:00.520 --> 00:13:01.760
Старый способ решения этой проблемы

00:13:01.760 --> 00:13:02.440
очень утомителен.

00:13:02.600 --> 00:13:03.560
Вы открываете портал.

00:13:03.680 --> 00:13:05.500
Копаетесь в настройках контейнерного приложения.

00:13:05.660 --> 00:13:07.000
Проверяете журналы развертывания.

00:13:07.200 --> 00:13:08.240
Пишите CLI-команды

00:13:08.240 --> 00:13:09.940
для получения диагностической информации.

00:13:10.160 --> 00:13:12.360
Сравниваете файлы конфигурации между средами.

00:13:12.560 --> 00:13:14.660
Вручную очлеживаете последовательность запуска,

00:13:14.860 --> 00:13:16.180
пытаясь понять, что сломалось.

00:13:16.180 --> 00:13:17.360
Это занимает часы.

00:13:17.440 --> 00:13:18.220
И подразумевает,

00:13:18.440 --> 00:13:19.980
что вы уже знаете, что искать.

00:13:20.120 --> 00:13:21.380
С Azure MCP-сервером

00:13:21.380 --> 00:13:22.440
все совершенно иначе.

00:13:25.840 --> 00:13:26.600
Вы используете инструменты Azure MCP

00:13:26.600 --> 00:13:28.300
и позволяете агенту провести диагностику.

00:13:28.480 --> 00:13:28.920
Вот и все.

00:13:29.140 --> 00:13:30.800
Агент считывает файлы вашего проекта,

00:13:30.940 --> 00:13:32.340
просматривает настройки приложения,

00:13:32.560 --> 00:13:33.960
проверяет конфигурацию контейнера

00:13:33.960 --> 00:13:34.860
и выявляет проблему.

00:13:35.060 --> 00:13:37.120
Ваша строка подключения к Azure App Configuration

00:13:37.120 --> 00:13:38.300
является лишь заполнителем.

00:13:38.440 --> 00:13:40.540
Она никогда не была настроена для работы в продакшене.

00:13:40.620 --> 00:13:42.500
Когда контейнерное приложение пытается запуститься,

00:13:42.700 --> 00:13:44.080
оно не может подключиться к конфигурации,

00:13:44.220 --> 00:13:45.740
выдает исключение и завершает работу.

00:13:45.740 --> 00:13:47.380
Агент не просто находит проблему,

00:13:47.560 --> 00:13:48.620
он предлагает решение.

00:13:48.820 --> 00:13:50.200
Создать хранилище конфигураций,

00:13:50.360 --> 00:13:51.900
задать переменные среды в приложении,

00:13:52.060 --> 00:13:53.780
обновить код для считывания этих переменных

00:13:53.780 --> 00:13:55.140
вместо жестко заданных значений,

00:13:55.320 --> 00:13:56.640
выполнить повторное развертывание,

00:13:56.800 --> 00:13:58.120
он проведет вас через каждый шаг,

00:13:58.280 --> 00:14:00.340
запрашивая разрешение перед внесением изменений.

00:14:00.460 --> 00:14:02.340
А вот теперь начинается самое интересное.

00:14:02.540 --> 00:14:04.160
Агент последовательно выполняет

00:14:04.160 --> 00:14:05.340
несколько операций в Azure.

00:14:05.520 --> 00:14:07.100
Он опрашивает Azure Resource Graph,

00:14:07.360 --> 00:14:08.420
чтобы найти приложения,

00:14:08.600 --> 00:14:09.820
связанные с вашим проектом.

00:14:10.000 --> 00:14:11.440
Определяет группу ресурсов.

00:14:11.440 --> 00:14:14.020
Создает хранилище конфигурации в той же группе.

00:14:14.180 --> 00:14:15.720
Обновляет контейнерное приложение,

00:14:15.980 --> 00:14:17.500
добавляя новую переменную среды.

00:14:17.620 --> 00:14:19.440
Вносит изменения в код вашего проекта.

00:14:19.560 --> 00:14:20.960
Запускает процесс развертывания,

00:14:20.960 --> 00:14:22.900
а затем проверяет, что Инпоинт работает.

00:14:23.120 --> 00:14:24.660
Все это занимает считанные минуты.

00:14:24.780 --> 00:14:26.260
Агент выполнил все операции в Azure,

00:14:26.500 --> 00:14:27.260
чтение ресурсов,

00:14:27.440 --> 00:14:28.040
создание новых,

00:14:28.240 --> 00:14:29.220
обновление конфигураций,

00:14:29.480 --> 00:14:31.280
запуск развертывания и проверку результатов.

00:14:31.360 --> 00:14:33.240
Вы не написали ни одной команды в CLI.

00:14:33.420 --> 00:14:34.560
Вы не лазили по порталу.

00:14:34.680 --> 00:14:35.840
Вы просто описали проблему

00:14:35.840 --> 00:14:37.200
и одобрили предложенные шаги.

00:14:37.320 --> 00:14:39.100
Это означает, что сложное устранение

00:14:39.100 --> 00:14:40.180
неполадок превращается

00:14:40.180 --> 00:14:41.760
из ручного процесса в простой диалог.

00:14:41.960 --> 00:14:43.220
Вам не нужно быть экспертом Azure,

00:14:43.440 --> 00:14:45.140
чтобы диагностировать и исправлять ошибки.

00:14:45.320 --> 00:14:46.720
Агент предоставляет экспертизу,

00:14:46.820 --> 00:14:48.100
а вы — контекст и одобрение.

00:14:48.100 --> 00:14:50.380
И вы можете попробовать это сами на тестовом приложении.

00:14:50.520 --> 00:14:52.100
Вам не нужны особые права доступа.

00:14:52.220 --> 00:14:53.520
Вам не нужно быть разработчиком.

00:14:53.680 --> 00:14:56.120
Вам понадобится только подписка Azure и ее ассистент,

00:14:56.260 --> 00:14:57.260
поддерживающий MCP.

00:14:57.400 --> 00:14:59.200
Как все это связано — общая картина.

00:14:59.340 --> 00:15:00.180
Теперь вы понимаете,

00:15:00.380 --> 00:15:01.220
из чего все состоит.

00:15:01.340 --> 00:15:02.960
MCP — это стандартный протокол.

00:15:03.100 --> 00:15:05.040
Azure MCP сервер — это реализация от Microsoft,

00:15:05.300 --> 00:15:06.640
а службы Azure — это инструменты,

00:15:06.740 --> 00:15:07.620
к которым он подключается.

00:15:07.760 --> 00:15:08.720
Но настоящая ценность

00:15:08.720 --> 00:15:09.960
не в каком-то отдельном элементе.

00:15:10.080 --> 00:15:11.660
Она в том, что все они работают вместе

00:15:11.660 --> 00:15:12.480
через один протокол.

00:15:12.580 --> 00:15:13.880
Как это выглядит на практике?

00:15:14.000 --> 00:15:14.680
Представьте агента,

00:15:14.680 --> 00:15:16.360
который может запрашивать логи Azure Monitor,

00:15:16.560 --> 00:15:18.120
проверять настройки конфигурации приложений,

00:15:18.320 --> 00:15:19.220
создавать новые ресурсы

00:15:19.220 --> 00:15:20.520
и развертывать обновленный код —

00:15:20.520 --> 00:15:21.400
все в рамках одной сессии.

00:15:21.520 --> 00:15:23.160
Это не четыре отдельные интеграции.

00:15:23.360 --> 00:15:24.340
Это один MCP сервер,

00:15:24.520 --> 00:15:25.660
выполняющий четыре действия

00:15:25.660 --> 00:15:27.300
последовательно с сохранением контекста

00:15:27.300 --> 00:15:28.020
на каждом шаге.

00:15:28.160 --> 00:15:29.540
Выходные данные одного инструмента

00:15:29.540 --> 00:15:30.960
становятся входными для следующего.

00:15:31.140 --> 00:15:33.160
Состояние сессии поддерживает связь между ними.

00:15:33.360 --> 00:15:34.740
Это создает эффекты взаимодействия,

00:15:34.880 --> 00:15:35.920
недоступные при использовании

00:15:35.920 --> 00:15:36.920
разрозненных инструментов.

00:15:37.060 --> 00:15:37.880
Агент читает логи,

00:15:38.000 --> 00:15:39.260
находит проблему в конфигурации,

00:15:39.420 --> 00:15:41.060
создает исправление и развертывает его,

00:15:41.060 --> 00:15:43.560
избавляя вас от ручного копирования данных между этапами.

00:15:43.720 --> 00:15:45.400
Сетевой эффект тоже начинает работать.

00:15:45.560 --> 00:15:47.300
По мере создания новых MCP серверов

00:15:47.300 --> 00:15:48.860
каждый и ассистент получает доступ

00:15:48.860 --> 00:15:50.100
к большему числу возможностей.

00:15:50.240 --> 00:15:51.900
У Microsoft уже есть MCP серверы

00:15:51.900 --> 00:15:52.600
для Azure DevOps,

00:15:52.800 --> 00:15:54.060
PlayRide и обработки документов.

00:15:54.240 --> 00:15:56.220
Сторонние разработчики тоже создают свои серверы.

00:15:56.340 --> 00:15:57.720
Каждый новый сервер добавляет инструменты,

00:15:57.780 --> 00:15:58.660
которыми может воспользоваться

00:15:58.660 --> 00:15:59.800
любой MCP-совместимый агент.

00:15:59.980 --> 00:16:01.260
Экосистема становится ценнее

00:16:01.260 --> 00:16:02.520
с каждым добавленным сервером.

00:16:02.620 --> 00:16:03.600
Теперь давайте посмотрим,

00:16:03.820 --> 00:16:04.760
к чему все это движется.

00:16:04.900 --> 00:16:06.480
Azure MCP сервер уже встроен

00:16:06.480 --> 00:16:08.340
в Visual Studio 2026.

00:16:08.340 --> 00:16:11.240
MCP сервер для Azure DevOps стал общедоступным.

00:16:11.400 --> 00:16:13.460
Azure API Management теперь поддерживает MCP,

00:16:13.600 --> 00:16:15.080
поэтому предприятия могут управлять

00:16:15.080 --> 00:16:16.640
и защищать свои MCP-инструменты

00:16:16.640 --> 00:16:18.240
так же, как они управляют своими API.

00:16:18.360 --> 00:16:20.320
А на конференции Build 2026

00:16:20.320 --> 00:16:22.320
Microsoft анонсировала агент-орчестратор,

00:16:22.440 --> 00:16:24.280
управляемый сервис для балансировки нагрузки,

00:16:24.440 --> 00:16:25.380
мониторинга состояния

00:16:25.380 --> 00:16:27.340
и распределения затрат между тысячами агентов.

00:16:27.460 --> 00:16:28.540
Первые пользователи добились

00:16:28.540 --> 00:16:30.240
снижения вычислительных затрат на агента

00:16:30.240 --> 00:16:31.840
на 30-45% благодаря

00:16:31.840 --> 00:16:33.280
интеллектуальной маршрутизации моделей.

00:16:33.400 --> 00:16:34.500
Общая картина ясна.

00:16:34.640 --> 00:16:37.720
MCP становится универсальным уровнем интеграции для ИИ.

00:16:37.720 --> 00:16:40.980
А Azure MCP сервер – это точка входа для пользователей Azure.

00:16:41.280 --> 00:16:43.380
Организации, которые внедрят MCP сейчас,

00:16:43.640 --> 00:16:45.480
смогут подключаться к любой и платформе

00:16:45.480 --> 00:16:47.000
без перестройки своих интеграций.

00:16:47.200 --> 00:16:48.580
Ваши инструменты, ваши данные,

00:16:48.860 --> 00:16:50.100
ваша модель безопасности –

00:16:50.100 --> 00:16:52.460
все доступно через один протокол любому и ассистенту,

00:16:52.560 --> 00:16:53.420
который его понимает.

00:16:53.520 --> 00:16:55.440
Это все, что я хотел рассказать сегодня.

00:16:55.600 --> 00:16:58.680
MCP дает и агентам стандартный способ общения с инструментами,

00:16:58.840 --> 00:17:00.800
а Azure MCP сервер предоставляет им доступ

00:17:00.800 --> 00:17:01.960
ко всей вашей среде Azure.

00:17:02.120 --> 00:17:03.780
Если вы разрабатываете и решение на Azure,

00:17:03.940 --> 00:17:05.360
начните изучать MCP уже сегодня.

00:17:05.360 --> 00:17:07.040
Подписывайтесь на свой любимый подкаст-платформе

00:17:07.040 --> 00:17:08.040
и поделитесь этим выпуском с тем,

00:17:08.200 --> 00:17:09.020
кто только начинает свой путь.

00:17:09.200 --> 00:17:10.000
Напишите в комментариях,

00:17:10.200 --> 00:17:11.180
если что-то показалось важным.

00:17:11.340 --> 00:17:12.400
Я читаю каждый отзыв.

00:17:12.560 --> 00:17:13.520
С вами был Мирко Питерс.

00:17:13.660 --> 00:17:14.660
И это был еще один выпуск

00:17:14.660 --> 00:17:15.900
Microsoft Knowledge на Getas.
