Переход с Azure на GCP, с ASP.NET MVC на ASP.NET Core 3.1

    Автор: Андрей Жуков, .NET Team Leader, DataArt

    В статье я описал собственный успешный опыт миграции реального проекта с одной облачной платформы на другую. Конечно, это не единственный возможный путь. Но думаю, здесь можно найти подсказки, которые облегчат жизнь всем, кому такой переход только предстоит. Тем не менее, вам придется учитывать особенности вашего проекта и руководствоваться здравым смыслом. 

    Задача, поставленная заказчиком: Azure -> GCP

    Заказчик решил перейти из одного облака (Azure) в другое (Google Cloud Platform). В некотором отдаленном будущем вообще планировалось перевести серверную часть на Node.js и развивать систему силами команды full-stack typescript-разработчиков. На момент моего входа в проект там существовала пара ASP.NET MVC приложений, которым решили продлить жизнь. Их мне и предстояло перенести в GCP.

    Начальная состояние, факторы, мешающие сразу перейти на GCP

    Первоначально имелось два ASP.NET MVC-приложения, которые взаимодействовали с одной общей MS SQL базой данных. Они были развернуты на Azure App Services.

    Первое приложение — назовем его Web Portal — имело пользовательский интерфейс, построенный на базе Razor, TypeScript, JavaScript, Knockout и Bootstrap. С этими клиентскими технологиями никаких проблем не предвиделось. Зато серверная часть приложения использовала несколько сервисов, специфичных для Azure: Azure Service Bus, Azure Blobs, Azure Tables storage, Azure Queue storage. С ними предстояло что-то делать, т. к. в GCP ни один из них не поддерживается. Кроме того, приложение использовало Azure Cache for Redis. Для обработки длительных запросов была задействована служба Azure WebJob, задачи которой передавались через Azure Service Bus. По словам программиста, занимавшегося поддержкой, фоновые задачи могли выполняться до получаса.

    Изначально архитектура Web Portal в нашем проекте выглядела так
    Изначально архитектура Web Portal в нашем проекте выглядела так

    Azure WebJobs тоже предстояло чем-то заменить. Архитектура с очередью заданий для длительных вычислений не единственное среди возможных решений — можно использовать специализированные библиотеки для фоновых задач, например, Hangfire, или обратиться к IHostedService от Microsoft.

    Второе приложение — назовем его Web API — представляло собой ASP.NET WEB API. Оно использовало только MS SQL базы данных. Вернее, в конфигурационном файле были ссылки на несколько баз данных, в реальности же приложение обращалось только к одной их них. Но об этом нюансе мне только предстояло узнать.

    Оба приложения были в работающем, но плохом состоянии: отсутствовала архитектура как таковая, было много старого неиспользуемого кода, не соблюдались принципы построения ASP.NET MVC приложений и т. д. Заказчик и сам признавал низкое качество кода, а человек, изначально написавший приложения, уже несколько лет не работал в компании. Был дан зеленый свет любым изменениям и новым решениям.

    Итак, нужно было перевести ASP.NET MVC приложения на ASP.NET Core 3.1, перевести WebJob c .NET Framework на .NET Core, чтобы можно было разворачивать их под Linux. Использовать Windows на GCP возможно, но не целесообразно. Надо было избавиться от сервисов, специфичных для Azure, заменить чем-то Azure WebJob, решить, как будем развертывать приложения в GCP, т. е. выбрать альтернативу Azure App Services. Требовалось добавить поддержку Docker. При этом неплохо было бы внести хоть какую-то архитектуру и поправить качество кода.

    Общие принципы и соображения

    Проводя рефакторинг, мы придерживались принципа пошаговых изменений: вся работа делилась на этапы, которые в свою очередь состояли из отдельных шагов.

    В конце каждого этапа приложение должно находиться в стабильном состоянии, т. е. пройти хотя бы Smoke tests.

    В конце каждого шага приложение или та его часть, которая подверглась изменению, также должны находиться в состоянии, близком к стабильному. Т. е. они  должны запускаться или, по крайней мере, быть в компилируемом состоянии, если этот шаг можно считать промежуточным.

    Шаги и этапы должны быть максимально короткими: работу нужно раздробить настолько, насколько это возможно. Порой нам все равно приходилось делать шаги, когда приложение не компилировалось в течение одного-двух дней. Случалось, что в конце шага компилировался только тот проект решения, который был недавно изменен. Если этап или шаг можно разбить по проектам, начинать работу надо с того проекта, который не зависит от других, и далее переходить к тем, которые зависят только от него, и т. д. План, который составили мы, представлен ниже.

    При замене сервисов Azure можно либо подобрать альтернативный GCP-сервис, либо выбрать cloud-agnostic-решение. Выбор сервисов в этом проекте и его обоснование в каждом случае мы рассмотрим отдельно.

    План работ

    Высокоуровневый план в целом был продиктован заказчиком, где-то я добавил шаги, о необходимости которых на стороне клиента не знали или не придали им значения. План немного корректировался в ходе работы. На некоторых этапах добавлялся рефакторинг архитектуры и кода, который непосредственно не относился к переходу на другую платформу. Окончательный вариант можно увидеть ниже. Каждый пункт этого плана – этап, в том смысле, что по его завершении приложение находится в стабильном состоянии. 

    1. Web Portal c ASP.NET MVC на ASP.NET Core

      1.1.  Анализ кода и зависимостей Web Portal от сервисов Azure и сторонних библиотек, оценка необходимого времени.

      1.2.  Перевод Web Portal на .NET Core.

      1.3.  Рефакторинг с целью устранения основных проблем.

      1.4.  Merge изменений Web Portal из основной ветки репозитория, сделанных параллельно другими разработчиками.

      1.5.  Докеризация Web Portal.

      1.6.  Тестирование Web Portal, устранение ошибок и развертывание новой версии на Azure.

    2. Web API c ASP.NET MVC на ASP.NET Core

      2.1.  Написание E2E автоматических тестов для Web API.

      2.2.  Анализ кода и зависимостей Web API от сервисов Azure и сторонних библиотек, оценка необходимого времени.

      2.3.  Удаление неиспользуемого исходного кода из Web API.

      2.4.  Перевод Web API на .NET Core.

      2.5.  Рефакторинг Web API с целью устранения основных проблем.

      2.6.  Merge изменений Web API из основной ветки репозитория, сделанных параллельно другими разработчиками.

      2.7.  Докеризация Web API.

      2.8.  Тестирование Web API, устранение ошибок и развертывание новой версии на Azure.

    3. Устранение зависимостей от Azure

      3.1.  Устранение зависимостей Web Portal от Azure.

    4. Развертывание в GCP

      4.1.  Развертывание Web Portal в тестовой среде в GCP.

      4.2.  Тестирование Web Portal и устранение возможных ошибок.

      4.3.  Миграция базы данных для тестовой среды.

      4.4.  Развертывание Web API в тестовой среде в GCP.

      4.5.  Тестирование Web API и устранение возможных ошибок.

      4.6.  Миграция базы данных для prod-среды.

      4.7.  Развертывание Web Portal и Web API в prod GCP.

    Целиком план представлен лишь в ознакомительных целях, далее в статье я постараюсь подробно раскрыть лишь наиболее интересные, с моей точки зрения, вопросы.

    .NET Framework -> .NET Core

    Перед началом переноса кода я нашел статью о миграции .Net Framework на .Net Core от Microsoft и далее ссылку на миграцию ASP.NET на ASP.NET Core.

    С миграцией не-Web-проектов все обстояло относительно просто:

    • преобразование формата хранения NuGet-пакетов с помощью Visual Studio 2019;

    • адаптирование списка этих пакетов и их версий;

    • переход с App.config в XML на settings.json и замена всех имеющихся обращений к конфигурационным значениям на новый синтаксис.

    Некоторые версии NuGet-пакетов Azure SDK претерпели изменения, повлекшие несовместимость. В большинстве случаев удалось найти не всегда самую новую, зато поддерживаемую кодом .NET Core версию, которая не требовала бы изменений в логике старого программного кода. Исключением стали пакеты для работы с Azure Service Bus и WebJobs SDK. Пришлось с Azure Service Bus перейти на бинарную сериализацию, а WebJob перевести на новую, обратно несовместимую версию SDK.

    C миграцией ASP.NET MVC на ASP.NET Core дело обстояло намного сложнее. Все перечисленные выше действия нужно было проделать и для Web-проектов. Но начинать пришлось с нового ASP.NET Core проекта, куда мы перенесли код старого проекта. Структура ASP.NET Core проекта сильно отличается от предшественника, многие стандартные классы ASP.NET MVC претерпели изменения. Ниже я привожу список того, что изменили мы, и большая его часть будет актуальна для любого перехода с ASP.NET MVC на ASP.NET Core.

    1. Создание нового проекта ASP.NET Core и перенос в него основного кода из старого ASP.NET MVC проекта.

    2. Корректировка зависимостей проекта от внешних библиотек (в нашем случае это были только NuGet-пакеты, соображения по поводу версий библиотек см. выше).

    3. Замена Web.config на appsettings.json и все связанные с этим изменения в коде.

    4. Внедрение стандартного механизма Dependency injection от .NET Core вместо любой его альтернативы, использовавшейся в Asp.NET MVC проекте.

    5.  Использование StaticFiles middleware для всех корневых папок статических файлов: изображений, шрифтов, JavaScript-скриптов, CSS-стилей и т. д.

    app.UseStaticFiles(); // wwwroot
    app.UseStaticFiles(new StaticFileOptions
       	{
         	FileProvider = new PhysicalFileProvider(
             Path.Combine(Directory.GetCurrentDirectory(), "Scripts")),
         	RequestPath = "/Scripts"
    });

    Можно перенести все статические файлы в wwwroot.

    6. Переход к использованию bundleconfig.json для всех JavaScript и CSS-бандлов вместо старых механизмов. Изменение синтаксиса подключения JavaScript и CSS:

    <link rel="stylesheet" href="~/bundles/Content.css" asp-append-version="true" />
    <script src="~/bundles/modernizr.js" asp-append-version="true"></script>

    Чтобы директива asp-append-version="true" работала корректно, бандлы (bundles) должны находиться в корне, т. е. в папке wwwroot (смотри здесь).

    Для отладки бандлов я использовал адаптированную версию хелпера отсюда

    7. Изменение механизма обработки UnhadledExceptions: в ASP.NET Core реализована его поддержка, остается с ней разобраться и использовать вместо того, что применялось в проекте раньше.

    8.     Логирование: я адаптировал старые механизмы логирования для использования стандартных в ASP.NET Core и внедрил Serilog. Последнее опционально, но, по-моему, сделать это стоит для получения гибкого structured logging c огромным количеством вариантов хранения логов.

    9.     Session — если в старом проекте использовалась сессия, то код обращения к ней надо будем немного адаптировать и написать хелпер для сохранения любого объекта, поскольку изначально поддерживается только строка.

    10.  Routing: в старом проекте использовался механизм, основанный на templates, его надо было чуть-чуть подправить.

    11.  JSON-сериализация:  В ASP.NET Core по умолчанию используется библиотека System.Text.Json вместо Newtonsoft.Json. Microsoft утверждает, что она работает быстрее предшественницы, однако, в отличие от последней, она не поддерживает многое из того, что Newtonsoft.Json умела делать из коробки безо всякого участия программиста. Хорошо, что есть возможность переключиться обратно на Newtonsoft.Json. Именно это я и сделал, когда выяснил, что большая часть сериализации в Web API была сломана, и вернуть ее в рабочее состояние с помощью новой библиотеки, если и возможно, очень непросто. Подробнее об использовании Newtonsoft.Json можно прочитать здесь

    12.  В старом проекте использовался Typescript 2.3. С его подключением пришлось повозиться, потребовалось установить Node.js, подобрать правильную версию пакета Microsoft.TypeScript.MSBuild, добавить и настроить tsconfig.json, поправить файл определений (Definitions) для библиотеки Knockout, кое-где добавить директивы //@ts-ignore

    13.  Код для принудительной поддержки HTTPS включается автоматически при включении этой опции в визарде проекта. Старый код, использующий пользовательский атрибут HttpsOnly, был при этом убран.

    14.  Все низкоуровневые действия, такие как получение параметров из body запроса, URL запроса, HTTP Headers и HttpContext потребовали изменений, т. к. API для доступа к ним претерпел изменения по сравнению с ASP.NET MVC. Работы было бы заметно меньше, если бы в старом проекте чаще использовались стандартные binding механизмы через параметры экшенов (Actions) и контроллеров (Controllers).

    15.  Был добавлен Swagger c помощью библиотеки Swashbuckle.AspNetCore.Swagger.

    16.  Нестандартный механизм Authentication потребовал рефакторинга для приведения его к стандартному виду.

    Количество изменений было очень велико, поэтому часто приходилось оставлять только один контроллер и добиваться его работоспособности. Другие мы затем добавляли постепенно, следуя принципу пошаговых изменений.

    Что делать со специфичными сервисами Azure?

    После перехода на ASP.NET Core предстояло избавиться от Azure-сервисов. Можно было либо подобрать решения, которые не зависят от облачной платформы, либо найти что-то подходящее из списка GCP. Благо у многих сервисов есть прямые альтернативы у других облачных провайдеров.

    Azure Service Bus мы по настоятельной рекомендации заказчика решили заменить на Redis Pub/Sub. Это достаточно простой инструмент, не настолько мощный и гибкий как, например, RabbitMQ. Но для нашего простого сценария его хватало, а в пользу такого выбора говорило то, что Redis в проекте уже использовался. Время подтвердило — решение было правильным. Логика работы с очередью была абстрагирована и выделена в два класса, один из которых реализует отправку произвольного объекта, другой получает сообщения и передает их на обработку. На выделение этих объектов ушло всего несколько часов, а если сам Redis Pub/Sub вдруг потребуется заменить, то и это будет очень просто.

    Azure Blobs были заменены на GCP Blobs. Решение очевидное, но все-таки различие в функциональности сервисов нашлось: GCP Blobs не поддерживает добавление данных в конец существующего блоба. В нашем проекте такой блоб использовался для создания подобия логов в формате CSV. На платформе Google мы решили записывать эту информацию в Google Cloud operations suite, ранее известный как Stackdriver.

    Хранилище Azure Table Storage использовалось для записи логов приложения и доступа к ним из Web Portal. Для этого существовал логгер, написанный самостоятельно. Мы решили привести этот процесс в соответствие с практиками от Microsoft, т. е. использовать их интерфейс ILogger. Кроме того, была внедрена библиотека для структурного логирования Serilog. В GCP логирование настроили в Stackdriver.

    Какое-то время проект должен был параллельно работать и на GCP, и на Azure. Поэтому вся функциональность, зависящая от платформы, была выделена в отдельные классы, реализующие общие интерфейсы: IBlobService, IRequestLogger, ILogReader. Абстрагирование логирования было достигнуто автоматически за счет использования библиотеки Serilog. Но для того, чтобы показывать логи в Web Portal, как это делалось в старом приложении, понадобилось адаптировать порядок записей в Azure Table Storage, реализуя свой Serilog.Sinks.AzureTableStorage.KeyGenerator.IKeyGenerator. В GCP для чтения логов изGoogle Cloud operations были созданы Log Router Sinks, передающие данные в BigQuery, откуда приложение и получало их.

    Что делать с Azure WebJobs?

    Сервис Azure WebJobs доступен только для Azure App Services on Windows. По сути он представляет собой консольное приложение, использующее специальный Azure WebJobs SDK. Зависимость от этого SDK я убрал. Приложение осталось постоянно работающим консольным и следует похожей логике:

    static async Task Main(string[] args)
    {
    ….
     
      var builder = new HostBuilder();
    
      ...            	
    
      var host = builder.Build();
    
      using (host)
      {
         await host.RunAsync();
      }
    ...
    }

    За всю работу отвечает зарегистрированный с помощью Dependency Injection класс

    public class RedisPubSubMessageProcessor : Microsoft.Extensions.Hosting.IHostedService
    {
    ...
    	public async Task StartAsync(CancellationToken cancellationToken)
    ...
    	public async Task StopAsync(CancellationToken cancellationToken)
    ...
    }

    Это стандартный для .NET Core механизм. Несмотря на отсутствие зависимости от Azure WebJob SDK, это консольное приложение успешно работает как Azure WebJob. Оно также без проблем работает в Linux Docker-контейнере под управлением Kubernetes, о чем речь в статье пойдет позже. 

    Рефакторинг по дороге

    Архитектура и код приложения были далеки от идеала. В ходе многих шагов постепенно производились небольшие изменения кода, который они затрагивали. Были и специально запланированные этапы рефакторинга, согласованные и оцененные вместе с заказчиком. На этих этапах мы устраняли проблемы с аутентификацией и авторизацией, переводили их на практики от Microsoft. Был отдельный этап по внесению некой архитектуры, выделению слоев, устранению ненужных зависимостей. Работа с Web API началась с этапа удаления неиспользуемого кода. При замене многих Azure-сервисов на первом этапе производилось определение интерфейсов, выделение данных зависимостей в отдельные классы.

    Все это, на мой взгляд, было необходимо и положительно сказалось на результате.

    Docker

    С поддержкой Docker все сложилось довольно гладко. Dockerfile можно легко добавить с помощью Visual Studio. Я добавил их для всех проектов, соответствующих приложениям, для Web Portal, Web API, WebJob (который в дальнейшем превратился просто в консольное приложение). Эти стандартные Dockerfile от Microsoft не претерпели особенных изменений и заработали из коробки за единственным исключением — пришлось в Dockerfile для Web Portal добавить команды для установки Node.js. Этого требует build контейнер для работы с TypeScript.

    RUN apt-get update && \
    	apt-get -y install curl gnupg && \
    	curl -sL https://deb.nodesource.com/setup_12.x  | bash - && \
    	apt-get -y install nodejs

    Azure App Services -> GKE

    Нет единственно правильного решения для развертывания .NET Core-приложений в GCP, вы всегда можете выбрать из нескольких опций:

    • App Engine Flex.

    • Kubernetes Engine.

    • Compute Engine.

    В нашем случае я остановился на Google Kubernetes Engine (GKE). Причем к этому моменту у нас уже были контейнеризованные приложения (Linux). GKE, оказалось, пожалуй, наиболее гибким из трех представленных выше решений. Оно позволяет разделять ресурсы кластера между несколькими приложениями, как в нашем случае. В принципе для выбора одного из трех вариантов можно воспользоваться блок-схемой по этой сслыке.

    Выше описаны все решения по используемым сервисам GCP, кроме MS SQL Server, который мы заменили на Cloud SQL от Google. 

    Архитектура нашей системы после миграции в GCP
    Архитектура нашей системы после миграции в GCP

    Тестирование

    Web Portal тестировался вручную, после каждого этапа я сам проводил простенький Smoke-тест. Это было обусловлено наличием пользовательского интерфейса. Если по завершении очередного этапа, новый кусок кода выпускался в Prod, к его тестированию подключались другие пользователи, в частности, Product Owner. Но выделенных QA-специалистов, в проекте, к сожалению, не было. Разумеется, все выявленные ошибки исправлялись до начала очередного этапа. Позднее был добавлен простой Puppeteer-тест, который исполнял сценарий загрузки одного из двух типов отчетов с какими-то параметрами и сравнивал полученный отчет с эталонным. Тест был интегрирован в CICD. Добавить какие-то юнит-тесты было проблематично по причине отсутствия какой-либо архитектуры.

    Первым этапом миграции Web API, наоборот, было написание тестов. Для это использовался Postman, затем эти тесты вызывались в CICD с помощью Newman. Еще раньше к старому коду была добавлена интеграция со Swagger, который помог сформировать начальный список адресов методов и попробовать многие из них. Одним из следующих шагов было определение актуального перечня операций. Для этого использовались логи IIS (Internet Information Services), которые были доступны за полтора месяца. Для многих актуальных методов перечня было создано несколько тестов с разными параметрами. Тесты, приводящие к изменению данных в базе, были выделены в отдельную Postman-коллекцию и не запускались на общих средах выполнения. Разумеется, все это было параметризовано, чтобы можно было запускать и на Staging, и на Prod, и на Dev.

    Тестирование позволило нам убедиться, что продукт после миграции сохранил стабильность. Конечно, идеальным вариантов было бы покрыть всю функциональность автоматизированными тестами. Поэтому в случае с Web API несмотря на гораздо большие усилия, затраченные в самом начале, миграция, поиск и исправление ошибок затем проходили гораздо легче.

    Azure MS SQL -> GCP Managed MS SQL

    Миграция MS SQL из Managed Azure в GCP Cloud SQL оказалась не такой простой задачей, как представлялось вначале. Основных причин тому оказался несколько:

    • Очень большой размер базы данных (Azure портал показал:  Database data storage /

      Used space 181GB).

    •    Наличие зависимостей от внешних таблиц.

    •  Отсутствие общего формата для экспорта из Azure и импорта в GCP Cloud SQL.

    При миграции базы я в основном опирался на статью на испанском, которую автоматически перевел в Google Chrome. Она оказалась самой полезной из всех, что мне удалось найти.

    Перед началом миграции нужно удалить все ссылки на внешние таблицы и базы данных, иначе миграция будет неудачной. Azure SQL поддерживает экспорт только в формат bacpac, более компактный по сравнению со стандартным backup форматом. В нашем случае вышло 6 Гб в bacpac против 154 Гб в backup. Но GCP Cloud позволят импортировать только backup, поэтому нам потребовалась конвертация, сделать которую удалось лишь посредством восстановления в локальную MS SQL из bacpac и создания backup уже из нее. Для этих операций потребовалось установить последнюю версию Microsoft SQL Server Management Studio, причем локальный сервер MS SQL Server был версией ниже. Немало операций заняли по многу часов, некоторые и вовсе длились по несколько дней. Рекомендую увеличить квоту Azure SQL перед импортом и сделать копию prod базы, чтобы импортировать из нее. Где-то нам потребовалось передавать файл между облаками, чтобы ускорить загрузку на локальную машину. Мы также добавили SSD-диск на 1 Тб специально под файлы базы данных.

    Задачи на будущее

    При переходе с Azure App Services на GCP Kubernetes мы потеряли CICD, Feature Branch deployments, Blue/Green deployment. На Kubernetes все это несколько сложнее и требует иной реализации, но наверняка делается посредством все тех же Github Actions. В новом облаке следуем концепции Iac (Infrastructure-as-Code) вместе с Pulumi.

    От старого приложения нам достались низкая производительность и слишком продолжительное время запросов к базе данных. Устранение этих проблем — среди приоритетов на ближайшее будущее.

    DataArt
    Технологический консалтинг и разработка ПО

    Похожие публикации

    Комментарии 16

      –2
      Наплачетесь с GCP. Пожалеете о переезде сначала, когда все будет лежать, а status.cloud.google.com будет весь зелененький, а потом когда попытаетесь обратиться к саппорту.

      Сколько там руководителей уже сменилось? Такое впечатление, что назначают нового аккурат перед каждым google io ))))
        0
        Azure другой? )
          0
          Про Azure с точки зрения пользователя сказать ничего не могу, был по другую сторону. А вот AWS точно на порядок лучше. И саппорт отвечает быстро и по делу, с техническими деталями, и post mortem'ы вменяемые
          0
          В AWS service health dashboard тоже evergreen статус )
          Падает вместе с control plane.
          +1

          Интересно почему "решил перейти из одно облака в другое"?


          Тем более что azure 19% от рынка облаков, а gcp 7%

            0
            может как раз поэтому, дешевле
              +2

              "Не гонялся бы ты поп за дешевизной".


              Если это не ресурс с миллионами запосов в месяц, то затраты на перенос/разработку вряд ли окупятся. Там не в разы разница, а в 10-20%. И не всегда в пользу gcp

                +2
                некоторые on-demand instance в разы, некоторые per-GB storage в разы, от типа зависит, но согласен интересно бы узнать реальную причину миграции
              +1
              Здравствуйте! Вот ответ Андрея, автора статьи:

              «Решение о переходе с Azure на GCP приняли без нас, еще до нашего появления в проекте. Сам бы я не взялся сравнивать Azure и GCP — боюсь, это сродни сравнению C# и Java: что лучше? У заказчика могут быть свои причины для выбора языка или платформы — например, наличие специалистов по определенной технологии внутри. Если вдруг, как в нашем случае, он хочет в будущем переписать проект заново на Node.js, нужно найти ему соответствующих разработчиков.

              По-моему, обе клауд-платформы хороши. Я бы не рискнул с ходу советовать одну из них в ущерб другой, за исключением, наверное, случая с .NET, когда все-таки напрашивается Azure. Но даже здесь это вовсе не обязательное решение, особенно с появлением .NET Core. Цены обе платформы стараются держать на сопоставимом уровне.

              Со слов заказчика, причинами перехода были:
              — отказ от .NET стека в будущем;
              — GKE как лучший Cloud Kubernetes.

              Полагаю, что Google мог предложить заказчику и финансово интересные условия, т. к. тот переходил на GCP из Azure. Но экономические детали вне моей компетенции — перед нашей командой задача перехода была поставлена уже как техническая. Ее решение я описал в статье».
              +3

              Самый важный вопрос: зачем переходили? Понятно, что заказчик попросил, но хотелось бы получить больше информации, о целях и результате

                0
                Ответили выше, спасибо!
                0
                Внедрение стандартного механизма Dependency injection от .NET Core вместо любой его альтернативы, использовавшейся в Asp.NET MVC проекте.

                Полезное изменение, но необязательное. С тем же успехом можно подключить уже существующий контейнер вместо стандартного.

                  0
                  Справедливое замечание, можно и так. Андрей как раз пишет, что перечисленные решения не единственные.
                  +2
                  Я не адепт какого то одного облака. Но хотелось бы подробностей. В чём был смысл миграции с Azure на GCP? Скорее всего можно было оптимизировать всё на Azure, и сократить косты в 1,5-2х раза.
                  — Сколько денег сэкономили заказчику (с учетом стоимости миграции)?
                  — ROI? Через сколько отобьется миграция (с учетом стоимости миграции)?
                  Если косты душили, может проще было мигрировать на Oracle Cloud?
                  Oracle cloud дешевле и AWS, Azure и GCP.
                  Между Oracle Cloud и Azure можно установить VCN/Vnet peering и плавно мигрировать.
                    +1
                    15. Был добавлен Swagger c помощью библиотеки Swashbuckle.AspNetCore.Swagger.

                    16. Нестандартный механизм Authentication потребовал рефакторинга для приведения его к стандартному виду.

                    Как это связано с миграцией?
                      0
                      «На некоторых этапах добавлялся рефакторинг архитектуры и кода, который непосредственно не относился к переходу на другую платформу». Решили рассказать обо всем, что происходило в проекте — по той же причине и раздел «Рефакторинг по дороге» добавили.

                    Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.

                    Самое читаемое