Сплошняк в архитектуре: #сплошняк Instagram posts (photos and videos)

3. Принцип замещения Лискова: Принцип был введен Барбарой Лисков в 1987 году, и согласно этому принципу « производных или дочерних классов должны быть заменены на их базовые или родительские классы ». Этот принцип гарантирует, что любой класс, являющийся дочерним по отношению к родительскому классу, можно использовать вместо своего родителя без какого-либо неожиданного поведения.
Вы можете понять это так, что сын фермера должен унаследовать фермерские навыки от своего отца и иметь возможность заменить своего отца в случае необходимости. Если сын хочет стать фермером, он может заменить своего отца, но если он хочет стать игроком в крикет, то определенно сын не может заменить своего отца, даже если они оба принадлежат к одной семейной иерархии.
Один из классических примеров этого принципа – четырехсторонний прямоугольник. Высота прямоугольника может иметь любое значение, а ширина – любое значение.Квадрат – это прямоугольник одинаковой ширины и высоты. Итак, мы можем сказать, что можем расширить свойства класса прямоугольника до класса квадрата. Для этого вам нужно поменять местами дочерний (квадратный) класс на родительский (прямоугольный) класс, чтобы он соответствовал определению квадрата с четырьмя равными сторонами, но производный класс не влияет на поведение родительского класса, поэтому, если вы сделаете это что это нарушит принцип замены Лискова. Проверьте ссылку Лисков Принцип замены для лучшего понимания.

4. Принцип разделения интерфейса: Этот принцип является первым принципом, который применяется к интерфейсам вместо классов в SOLID, и он аналогичен принципу единой ответственности. В нем говорится, что « не заставляет клиентов реализовывать интерфейс, который им не важен ». Здесь ваша главная цель – сосредоточиться на том, чтобы избежать толстого интерфейса и отдать предпочтение множеству небольших клиентских интерфейсов. Вы должны предпочесть множество клиентских интерфейсов, а не один общий интерфейс, и каждый интерфейс должен иметь определенную ответственность.
Предположим, вы входите в ресторан и являетесь чистым вегетарианцем. Официант в этом ресторане дал вам карточку меню, которая включает вегетарианские и невегетарианские блюда, напитки и сладости. В этом случае у вас, как у клиента, должно быть меню, которое включает только вегетарианские блюда, а не все, что вы не едите в еде. Здесь меню должно быть разным для разных категорий клиентов. Карточку общего или общего меню для всех можно разделить на несколько карточек вместо одной.Использование этого принципа помогает уменьшить побочные эффекты и частоту необходимых изменений.

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

• Модули / классы высокого уровня не должны зависеть от модулей / классов низкого уровня.Оба должны зависеть от абстракций.
• Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.

В приведенных выше строках просто говорится, что если высокоуровневый модуль или класс будет больше зависеть от низкоуровневых модулей или класса, тогда ваш код будет иметь тесную связь, и если вы попытаетесь внести изменения в один класс, он может сломать другой класс, который рискованно на производственном уровне. Поэтому всегда старайтесь делать классы как можно слабее связанными, и вы можете добиться этого с помощью абстракции .Основной мотив этого принципа – разделение зависимостей, чтобы, если класс A изменится, классу B не нужно будет заботиться об изменениях или знать об этих изменениях.
Можно рассмотреть реальный пример батарейки пульта ДУ телевизора. Вашему пульту дистанционного управления нужна батарея, но это не зависит от марки батареи. Вы можете использовать любой бренд XYZ, который хотите, и он будет работать. Таким образом, мы можем сказать, что пульт от телевизора слабо связан с торговой маркой. Инверсия зависимостей делает ваш код более пригодным для повторного использования.

Думайте ИДЕАЛЫ, а не ТВЕРДОСТЬ

Основные выводы

• В объектно-ориентированном дизайне мы следуем принципам SOLID.При проектировании микросервисов мы предлагаем разработчикам следовать «ИДЕЛАМ»: разделение интерфейсов, возможность развертывания (зависит от вас), управляемость событиями, доступность выше согласованности, слабая связь и единоличная ответственность.
• Разделение интерфейса говорит нам, что различные типы клиентов (например, мобильные приложения, веб-приложения, программы CLI) должны иметь возможность взаимодействовать со службами через контракт, который лучше всего соответствует их потребностям.
• Deployability (на вас) подтверждает, что в эпоху микросервисов, которая также является эпохой DevOps, разработчикам необходимо принять критически важные проектные решения и технологический выбор в отношении упаковки, развертывания и запуска микросервисов.
• «Управляемый событиями» предполагает, что, когда это возможно, мы должны моделировать наши службы для активации асинхронным сообщением или событием вместо синхронного вызова. Доступность важнее согласованности напоминает нам, что чаще конечные пользователи ценят доступность системы выше согласованности данных, и их устраивает конечная согласованность.
• Слабая связь остается важной проблемой проектирования в случае микросервисов в отношении афферентной (входящей) и эфферентной (исходящей) связи. Единая ответственность – это идея, которая позволяет моделировать микросервисы, которые не являются слишком большими или слишком тонкими, потому что они содержат необходимое количество связной функциональности.
  

В 2000 году Роберт К. Мартин составил пять принципов объектно-ориентированного проектирования, перечисленных ниже. Позднее Майкл Фезерс объединил эти принципы в аббревиатуре SOLID. С тех пор принципы SOLID для объектно-ориентированного проектирования были описаны в книгах и стали широко известны в отрасли.

• Принцип единоличной ответственности
• Принцип открытия / закрытия
• Принцип замещения Лискова
• Принцип разделения интерфейса
• Принцип инверсии зависимостей

Пару лет назад я преподавал дизайн микросервисов другим разработчикам, когда один из студентов спросил: «Применимы ли принципы SOLID к микросервисам?» Поразмыслив, я ответил: «Отчасти».

Спустя несколько месяцев я обнаружил, что ищу фундаментальные принципы проектирования микросервисов (и броский акроним). Но почему такой вопрос важен?

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

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

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

Хотя некоторые принципы SOLID применимы к микросервисам, объектная ориентация – это парадигма проектирования, которая имеет дело с элементами (классами, интерфейсами, иерархиями и т. Д.), Которые фундаментально отличаются от элементов в распределенных системах в целом и микросервисах в частности.

Таким образом, мы предлагаем следующий набор основных принципов проектирования микросервисов:

• I Межфазная сегрегация
• D Возможность применения (на вас)
• E с вентиляционным приводом
• A доступность выше согласованности
• L Муфта Oose
• S единоличная ответственность

Принципы не охватывают весь спектр проектных решений для решений на основе микросервисов, но они затрагивают ключевые проблемы и факторы успеха для создания современных систем на основе услуг.Читайте объяснение этих принципов применительно к микросервисам – столь необходимому микросервису «IDEALS».

Разделение интерфейсов

Исходный принцип разделения интерфейсов предписывает объектно-ориентированным классам использовать «толстые» интерфейсы. Другими словами, вместо интерфейса класса со всеми возможными методами, которые могут понадобиться клиентам, должны быть отдельные интерфейсы, обслуживающие конкретные потребности каждого типа клиента.

Стиль микросервисной архитектуры – это специализация сервис-ориентированной архитектуры, в которой дизайн интерфейсов (т.д., сервисные контракты) всегда имела первостепенное значение. Начиная с начала 2000-х, литература по SOA предписывала канонические модели или канонические схемы, которым должны соответствовать все клиенты служб. Однако наш подход к разработке контрактов на обслуживание изменился со времен SOA. В эпоху микросервисов часто существует множество клиентских программ (внешних интерфейсов) для одной и той же логики обслуживания. Это основная мотивация применения сегрегации интерфейсов к микросервисам.

Реализация разделения интерфейса для микросервисов

Цель разделения интерфейса для микросервисов состоит в том, чтобы каждый тип внешнего интерфейса видел контракт на обслуживание, который наилучшим образом соответствует его потребностям.Например: мобильное собственное приложение хочет вызвать конечные точки, которые отвечают коротким представлением данных в формате JSON; в той же системе есть веб-приложение, использующее полное представление JSON; есть также старое настольное приложение, которое вызывает ту же службу и требует полного представления, но в XML. Разные клиенты также могут использовать разные протоколы. Например, внешние клиенты хотят использовать HTTP для вызова службы gRPC.

Вместо того, чтобы пытаться навязать один и тот же сервисный контракт (с использованием канонических моделей) для всех типов сервисных клиентов, мы «разделяем интерфейс», чтобы каждый тип клиента видел интерфейс сервиса, который ему нужен.Как мы это делаем? Отличной альтернативой является использование шлюза API. Он может выполнять преобразование формата сообщений, преобразование структуры сообщений, мосты протоколов, маршрутизацию сообщений и многое другое. Популярной альтернативой является шаблон Backend for Frontend (BFF). В этом случае у нас есть шлюз API для каждого типа клиента – мы обычно говорим, что у нас разные BFF для каждого клиента, как показано на этом рисунке.

Возможность развертывания (на вас)

Практически на протяжении всей истории разработки программного обеспечения усилия по проектированию были сосредоточены на проектных решениях, связанных с тем, как организованы единицы (модули) реализации и как взаимодействуют элементы (компоненты) среды выполнения. Архитектурные тактики, шаблоны проектирования и другие стратегии проектирования предоставили руководящие принципы для организации элементов программного обеспечения на уровнях, избежания чрезмерных зависимостей, назначения определенных ролей или задач определенным типам компонентов и других проектных решений в области «программного обеспечения». Для разработчиков микросервисов существуют важные проектные решения, выходящие за рамки программных элементов.

Как разработчики, мы давно осознаем важность правильной упаковки и развертывания программного обеспечения в соответствующей топологии времени выполнения.Однако мы никогда не уделяли так много внимания развертыванию и мониторингу времени выполнения, как сегодня с помощью микросервисов. Сфера технологий и дизайнерских решений, которые мы здесь называем «развертываемость», стала критически важной для успеха микросервисов. Основная причина заключается в том, что микросервисы резко увеличивают количество единиц развертывания.

Итак, буква D в IDEALS указывает разработчику микросервисов, что они также несут ответственность за обеспечение доступности программного обеспечения и его новых версий для счастливых пользователей. Всего возможность развертывания включает:

• Настройка инфраструктуры времени выполнения, которая включает контейнеры, модули, кластеры, постоянство, безопасность и сеть.
• Расширение и уменьшение микросервисов или их перенос из одной среды выполнения в другую.
• Ускорение процесса фиксации + сборки + тестирования + развертывания.
• Минимизация времени простоя для замены текущей версии.
• Синхронизация изменений версий связанного программного обеспечения.
• Контроль состояния микросервисов для быстрого выявления и устранения неисправностей.

Достижение хорошей возможности развертывания

Автоматизация – ключ к эффективному развертыванию. Автоматизация предполагает разумное использование инструментов и технологий, и именно в этой сфере мы постоянно наблюдаем самые большие изменения с момента появления микросервисов. Поэтому разработчики микросервисов должны искать новые направления с точки зрения инструментов и платформ, но всегда ставить под сомнение преимущества и проблемы каждого нового выбора. (Важными источниками информации были отчет ThoughtWorks Technology Radar и отчет InfoQ Trends об архитектуре и дизайне программного обеспечения.)

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

• Контейнеризация и оркестрация контейнеров : контейнерные микросервисы намного проще реплицировать и развертывать на платформах и облачных провайдерах, а платформа оркестрации предоставляет общие ресурсы и механизмы для маршрутизации, масштабирования, репликации, балансировки нагрузки и т. Д.Docker и Kubernetes сегодня являются стандартами де-факто для контейнеризации и оркестровки контейнеров.
• Service mesh : этот вид инструментов может использоваться для мониторинга трафика, применения политик, аутентификации, RBAC, маршрутизации, автоматического выключателя, преобразования сообщений, среди прочего, чтобы помочь с коммуникацией в платформе оркестровки контейнеров. Популярные сервисные сети включают Istio, Linkerd и Consul Connect.
• API-шлюз : перехватывая вызовы микросервисов, продукт API-шлюза предоставляет широкий набор функций, включая преобразование сообщений и мосты протоколов, мониторинг трафика, средства управления безопасностью, маршрутизацию, кеширование, регулирование запросов и квоты API, а также разрыв цепи.Видные игроки в этой сфере включают Ambassador, Kong, Apiman, WSO2 API Manager, Apigee и Amazon API Gateway.
• Бессерверная архитектура : вы можете избежать значительной части сложности и эксплуатационных затрат, связанных с оркестровкой контейнеров, развернув свои службы на бессерверной платформе, которая следует парадигме FaaS. AWS Lambda, Функции Azure и Google Cloud Functions являются примерами бессерверных платформ.
• Инструменты мониторинга : с микросервисами, распределенными по вашей локальной и облачной инфраструктуре, критически важно иметь возможность прогнозировать, обнаруживать и уведомлять о проблемах, связанных с работоспособностью системы. Доступно несколько инструментов мониторинга, таких как New Relic, CloudWatch, Datadog, Prometheus и Grafana.
• Инструменты консолидации журналов : микросервисы могут легко увеличить количество единиц развертывания на порядок. Нам нужны инструменты для консолидации журналов, выводимых этими компонентами, с возможностью поиска, анализа и генерации предупреждений. Популярные инструменты в этой области – Fluentd, Graylog, Splunk и ELK (Elasticsearch, Logstash, Kibana).
• Инструменты трассировки : эти инструменты могут использоваться для инструментария ваших микросервисов, а затем для создания, сбора и визуализации данных трассировки времени выполнения, которые показывают вызовы между сервисами.Они помогают обнаружить проблемы с производительностью (а иногда даже помогают понять архитектуру). Примерами инструментов трассировки являются Zipkin, Jaeger и AWS X-Ray.
• DevOps : микросервисы работают лучше, когда разработчики и операторы общаются и взаимодействуют более тесно, от настройки инфраструктуры до обработки инцидентов.
• Сине-зеленое развертывание и канареечный выпуск : эти стратегии развертывания допускают нулевое или почти нулевое время простоя при выпуске новой версии микросервиса с быстрым переключением в случае возникновения проблем.
• Инфраструктура как код (IaC) : эта практика позволяет минимизировать участие человека в цикле сборки-развертывания, который становится более быстрым, менее подверженным ошибкам и более контролируемым.
• Непрерывная доставка : это необходимая практика для сокращения интервала от фиксации до развертывания при сохранении качества решений. Традиционные инструменты CI / CD включают Jenkins, GitLab CI / CD, Bamboo, GoCD, CircleCI и Spinnaker. Совсем недавно в ландшафт были добавлены инструменты GitOps, такие как Weaveworks и Flux, сочетающие в себе CD и IaC.
• Внешняя конфигурация : этот механизм позволяет сохранять свойства конфигурации вне модуля развертывания микросервисов и легко управлять ими.

Событийный

Архитектурный стиль микросервисов предназначен для создания (серверных) сервисов, которые обычно активируются с использованием одного из этих трех общих типов соединителей:

• HTTP-вызов (в службу REST) ​​
• RPC-подобный вызов с использованием технологии компонентов для конкретной платформы, такой как gRPC или GraphQL
• Асинхронное сообщение, которое проходит очередь в посреднике сообщений

Первые два обычно являются синхронными, а HTTP-вызовы являются наиболее распространенной альтернативой.Часто сервисам необходимо вызывать других, формирующих сервисную композицию, и во многих случаях взаимодействие в сервисной композиции составляет синхронно . Если вместо этого мы создадим (или адаптируем) участвующие службы для подключения и получения сообщений из очереди / темы, мы создадим архитектуру, управляемую событиями. (Можно обсуждать разницу между управляемым сообщениями и событиями, но мы будем использовать эти термины как взаимозаменяемые для представления асинхронной связи по сети с использованием очереди / темы, предоставляемой продуктом брокера сообщений, таким как Apache Kafka, RabbitMQ и Amazon SNS. )
Важным преимуществом архитектуры, управляемой событиями, является улучшенная масштабируемость и пропускная способность. Это преимущество связано с тем, что отправители сообщений не блокируются в ожидании ответа, и одно и то же сообщение / событие могут использоваться параллельно несколькими получателями в режиме публикации-подписки.

Микросервис, управляемый событиями

Буква E в IDEALS напоминает нам о стремлении к моделированию микросервисов, управляемых событиями, поскольку они с большей вероятностью будут соответствовать требованиям масштабируемости и производительности современных программных решений.Такой дизайн также способствует слабой связи, поскольку отправители и получатели сообщений – микросервисы – независимы и не знают друг о друге. Надежность также повышается, потому что конструкция может справляться с временными отключениями микросервисов, которые позже могут догнать обработку сообщений, помещенных в очередь.

Но микросервисы, управляемые событиями, также известные как реактивные микросервисы, могут создавать проблемы. Обработка активируется асинхронно и происходит параллельно, возможно, требуя точек синхронизации и идентификаторов корреляции.Дизайн должен учитывать ошибки и потерянные сообщения – часто необходимы корректирующие события и механизмы отмены изменений данных, такие как шаблон Saga. А для пользовательских транзакций, переносимых посредством управляемой событиями архитектуры, пользовательский интерфейс должен быть тщательно продуман, чтобы держать конечного пользователя в курсе о прогрессе и неудачах.

Доступность по сравнению с согласованностью

Теорема CAP по существу дает вам два варианта: согласованность XOR доступности.Мы видим огромные усилия в отрасли, чтобы предоставить механизмы, которые позволят вам выбирать доступность, следовательно, охват конечной согласованности . Причина проста: сегодняшние конечные пользователи не будут мириться с отсутствием доступности. Представьте себе интернет-магазин во время Черной пятницы. Если мы обеспечим строгую согласованность между количеством запасов, отображаемым при просмотре продуктов, и фактическими запасами, обновленными при покупках, возникнут значительные накладные расходы на изменение данных. Если бы какая-либо служба, обновляющая запасы, была временно недоступна, каталог не мог бы отображать информацию о запасах, и касса перестала бы работать! Если вместо этого мы выберем доступность (принимая риск случайных несоответствий), пользователи смогут совершать покупки на основе данных о запасах, которые могут быть немного устаревшими.Одна из нескольких сотен или тысяч транзакций может закончиться тем, что неудачливый пользователь позже получит электронное письмо с извинениями за отмену покупки из-за неверной информации о запасах во время оформления заказа. Тем не менее, с точки зрения пользователей (и бизнеса) этот сценарий лучше, чем когда система недоступна или очень медленная для всех пользователей, потому что система пытается обеспечить строгую согласованность.

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

Доступность с конечной согласованностью

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

• Шаблон репликации служебных данных : этот базовый шаблон используется, когда микросервису требуется доступ к данным, принадлежащим другим приложениям (и вызовы API не подходят для получения данных). Мы создаем копию этих данных и делаем ее доступной для микросервиса.Для решения также требуется механизм синхронизации данных (например, инструмент / программа ETL, обмен сообщениями публикация-подписка, материализованные представления), который будет периодически или на основе триггера обеспечивать согласованность реплик и основных данных.
• Шаблон разделения ответственности за запросы команд (CQRS) : здесь мы отделяем разработку и реализацию операций, которые изменяют данные (команды), от операций, которые только читают данные (запросы). CQRS обычно основывается на репликации служебных данных для запросов для повышения производительности и автономности.
• Шаблон источника событий : вместо сохранения текущего состояния объекта в базе данных мы сохраняем последовательность неизменяемых событий только для добавления, которые повлияли на этот объект. Текущее состояние получается путем воспроизведения событий, и мы делаем это, чтобы обеспечить «просмотр запроса» данных. Таким образом, Event Sourcing обычно строится на основе CQRS.

Дизайн CQRS, который мы часто используем на моем рабочем месте, показан на рисунке ниже. HTTP-запросы, которые могут изменять данные, обрабатываются службой REST, которая работает с централизованной базой данных Oracle (тем не менее, эта служба использует шаблон «База данных для микросервиса»).HTTP-запросы только для чтения поступают в другую внутреннюю службу, которая считывает данные из текстового хранилища данных Elasticsearch. Задача Spring Batch Kubernetes cron периодически выполняется для обновления хранилища Elasticsearch на основе изменений данных, выполняемых в базе данных Oracle. Эта настройка использует возможную согласованность между двумя хранилищами данных. Служба запросов доступна, даже если база данных Oracle или задание cron не работают.

Свободная муфта

В программной инженерии связь означает степень взаимозависимости между двумя программными элементами.Для систем на основе услуг афферентная связь связана с тем, как пользователи услуги взаимодействуют с услугой. Мы знаем, что это взаимодействие должно осуществляться через контракт на обслуживание. Кроме того, контракт не должен быть тесно связан с деталями реализации или конкретной технологией. Сервис – это распределенный компонент, который может вызываться разными программами. Иногда хранитель службы даже не знает, где находятся все пользователи службы (часто бывает в случае общедоступных служб API). Таким образом, следует избегать изменения контракта.Если сервисный контракт тесно связан с сервисной логикой или технологией, то он более подвержен изменениям, когда логика или технология нуждаются в развитии.

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

Стратегии слабой связи для услуг

Буква L в IDEALS побуждает нас быть внимательными к связыванию для сервисов и, следовательно, микросервисов. Можно использовать и комбинировать несколько стратегий, чтобы способствовать (афферентной и эфферентной) слабой связи. Примеры таких стратегий включают:

• «точка-точка» и «публикация-подписка» : эти шаблоны обмена сообщениями из стандартных блоков и их варианты способствуют слабой связи, поскольку отправители и получатели не знают друг друга; договор реактивного микросервиса (например,g. , потребитель Kafka) становится именем очереди сообщений и структурой сообщения.
• API-шлюз и BFF : эти решения предписывают промежуточный компонент, который устраняет любые несоответствия между контрактом службы и форматом сообщения и протоколом, которые клиент хочет видеть, тем самым помогая их разъединить.
• Дизайн сначала контракта : разрабатывая контракт независимо от любого существующего кода, мы избегаем создания API, тесно связанных с технологией и реализацией.
• Hypermedia : для служб REST гипермедиа помогает внешним интерфейсам быть более независимыми от конечных точек службы.
• Шаблоны фасадов и адаптеров / оболочек : вариации этих шаблонов GoF в микросервисных архитектурах могут предписывать внутренние компоненты или даже службы, которые могут предотвратить нежелательное связывание, распространяющееся по реализации микросервиса.
• База данных в шаблоне микросервиса : с помощью этого шаблона микросервисы не только получают автономию, но и избегают прямого соединения с общими базами данных.

Единоличная ответственность

Исходный принцип единой ответственности (SRP) – это согласованная функциональность в объектно-ориентированном классе. Наличие нескольких обязанностей в классе, естественно, ведет к тесной связи и приводит к хрупким проектам, которые трудно развивать и которые могут неожиданно сломаться при изменении. Идея проста, но, как заметил дядя Боб, SRP очень легко понять, но трудно понять.

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

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

Правосторонние микросервисы

Важным аспектом зрелости проектирования микросервисов является способность создавать микросервисы, которые не являются слишком грубыми или слишком мелкими. Здесь решение не в каком-либо инструменте или технологии, а скорее в собственном моделировании предметной области .Моделирование серверных сервисов и определение границ микросервисов для них можно выполнять разными способами. Подход, который стал популярным в отрасли для увеличения объема микросервисов, заключается в следовании принципам Domain-Driven Design (DDD). Вкратце:

• Служба (например, служба REST) ​​может иметь объем агрегата DDD.
• Микрослужба может иметь область ограниченного контекста DDD. Сервисы в этом микросервисе будут соответствовать агрегатам в этом ограниченном контексте.
• Для взаимодействия между микросервисами мы можем использовать: события домена, когда асинхронный обмен сообщениями соответствует требованиям; Вызовы API с использованием некоторой формы уровня защиты от коррупции, когда соединитель запрос-ответ более подходит; или репликация данных с конечной согласованностью, когда микросервису требуется значительный объем данных из других доступных BC.

Заключение

IDEALS – это основные принципы проектирования, которым необходимо следовать в большинстве типичных проектов микросервисов.Однако следование ИДЕАЛАМ – это не волшебное зелье или заклинание, которые сделают нашу микросервисную разработку успешной. Как всегда, нам нужно хорошо понимать требования к атрибутам качества и принимать решения о проектировании с учетом их компромиссов. Более того, мы должны узнать о шаблонах проектирования и архитектурных тактиках, которые можно использовать для реализации принципов проектирования. Мы также должны хорошо разбираться в доступных технологиях.

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

Большое спасибо Джо Йодеру за помощь в воплощении этих идей в ИДЕАЛЫ.

Об авторе

Пауло Мерсон занимается программированием в малом и программирует в большом более 30 лет. Он является разработчиком в Федеральной счетной палате Бразилии. Он также является приглашенным научным сотрудником Института программной инженерии (SEI), сертифицированным инструктором Arcitura и преподавателем магистерской программы по прикладным вычислениям в Университете Бразилиа (UnB). Пауло часто проводит профессиональное обучение для своих коллег-разработчиков из США, Латинской Америки и Европы.Он является соавтором книги Documenting Software Architectures: Views and Beyond, 2nd edition . Пауло имеет степень бакалавра наук в области вычислительной техники UnB и степень магистра программной инженерии Университета Карнеги-Меллона. Вы найдете его в Linkedin, StackOverflow и Strava.

Архитектура программного обеспечения SOLID: Полное руководство с примерами кодирования

В этом курсе вы подробно изучите принципы проектирования архитектуры программного обеспечения SOLID для объектно-ориентированного программирования.Вы узнаете, каковы преимущества (а иногда и недостатки!) Каждого из принципов SOLID, а именно:

• Принцип единой ответственности
• Принцип открытости / закрытости
• Принцип подстановки Лискова
• Принцип разделения интерфейса
• Принцип инверсии зависимостей

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

Примеры написания кода приведены на C #, широко используемом объектно-ориентированном языке программирования. Однако, если вы не знакомы с C #, но используете другой объектно-ориентированный язык программирования (например,грамм. Java, PHP, Python и т. Д.), Не беспокойтесь, вы все равно сможете полностью понять различные принципы и объем каждого рефакторинга. Кроме того, если вы хотите, чтобы я рассмотрел аналогичный пример кода на другом языке программирования, просто отправьте мне сообщение, и я буду рад помочь вам с ним.

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

Некоторые из многих положительных отзывов, которые я получил на данный момент:

“ Курс исчерпывающий и хорошо объяснен с помощью четких и кратких примеров и показывает, что преподаватель имеет большой опыт в своей области.В целом этот курс превосходен и очень подходит для разработчиков программного обеспечения, стремящихся улучшить свои архитектурные и программные навыки, как начинающих, так и более продвинутых программистов. Я с нетерпением жду новых курсов автора в будущем. “- Дж. Фуссельберг

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

Я с нетерпением жду встречи с вами на моем курсе и услышу, как материалы помогают вам в работе или учебе!

Руководство по повышению квалификации

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

Работая в отрасли более 7 лет, у меня была возможность поработать с компаниями от ранних стартапов до Fortune 500.Они очень разные по организации работы. Тем не менее, они удивительно похожи в одном: снижение расходов за счет правильной архитектуры программного обеспечения.

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

SOLID – это аббревиатура, образованная из названий 5 принципов проектирования, направленных на улучшение дизайна кода, ремонтопригодность и расширяемость.Эти принципы были впервые представлены Робертом Мартином (более известным в кругах разработчиков как дядя Боб) в его статье 2000 года «Принципы проектирования и шаблоны проектирования». Позднее эти принципы были названы Майклом Фезерсом, который изменил их порядок, чтобы они могли образовать акроним.

Принципы программного обеспечения SOLID помогут вам:

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

Проще говоря, принципы SOLID Laravel действуют как принципы UX для разработчиков. Вы когда-нибудь работали над ошибкой, при которой вам приходилось часами читать код, чтобы понять, что делать? Отличный опыт разработчика означает, что вы можете легко перемещаться по коду и понимать, что он делает. В конечном итоге это приводит к тому, что тратится меньше времени на выяснение того, что делает код, и больше времени на разработку решения.

Итак, давайте рассмотрим 5 принципов разработки программного обеспечения SOLID для объектно-ориентированного дизайна, которые помогут нам стать лучшими разработчиками.

Принцип единой ответственности – буква S в SOLID. Несомненно, самый популярный из них, о котором говорят многие, – это первое, с чего вам следует начать.

Единоличная ответственность означает, что ваш класс (любая сущность в этом отношении, включая метод в классе или функцию в структурированном программировании) должен делать только одно. Если ваш класс отвечает за получение данных пользователей из базы данных, он также не должен заботиться об отображении данных.Это разные обязанности, и их следует решать отдельно.

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

Пишите маленькие классы с очень конкретными именами в отличие от больших классов с общими именами.Например, вместо того, чтобы бросать все внутри класса Employee , разделите обязанности на EmployeeTimeLog , EmployeeTimeOff , EmployeeSalary , EmployeeDetails и т. Д. Теперь у вас есть назначенное место для всего, и вы точно знаете, где посмотрите, когда вы вернетесь к своему коду через год.

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

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

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

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

Вместо этого попробуйте создать PayableInterface , который будет руководить реализацией каждого варианта оплаты. Тогда для каждого варианта оплаты у вас будет отдельный класс, реализующий этот интерфейс. Теперь ядро ​​вашей системы закрыто для модификации (вам не нужно менять его каждый раз, когда вы добавляете новый способ оплаты), но открыто для расширения (вы можете добавлять новые варианты оплаты, добавляя новые классы).

Принцип подстановки Лискова был впервые представлен Барбарой Лисков (американский ученый-компьютерщик) в конце 80-х. Математическая формулировка выглядит так:

«Пусть φ (x) будет доказуемым свойством для объектов x типа T. Тогда φ (y) должно быть истинным для объектов y типа S, где S – подтип T.»

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

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

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

Принцип разделения интерфейса гласит, что вы никогда не должны заставлять клиента зависеть от методов, которые он не использует.Давайте вернемся к примеру принципа единой ответственности.

Представьте, что у вас есть большой класс Employee со всеми методами, необходимыми для управления сотрудниками в вашей системе. Затем у вас есть несколько контроллеров, разработанных в стиле RESTful, по одному для каждой функции, которая вам нужна на вашем веб-сайте (например, EmployeeTimeLogController , EmployeeTimeOffController , EmployeeSalaryController , EmployeeDetailsController и т. Д.). Теперь все эти контроллеры зависят от класса Employee для обработки соответствующих функций. Изменение чего-либо в классе Employee может привести к поломке всех этих контроллеров, потому что все они зависят от этого.

Разделите класс Employee на более мелкие классы с определенными интерфейсами. Как только вы это сделаете, настройте контроллеры, чтобы все они зависели только от необходимых им интерфейсов.Таким образом, у вас будет чистая структура, в которой клиент зависит только от методов, которые он использует. Изменение чего-либо в определенном классе повлияет только на те части системы, которые фактически от него зависят.

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

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

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

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

FAQ

Вопрос: Что подразумевается под твердыми принципами?

SOLID – это аббревиатура, образованная названиями 5 принципов проектирования, направленных на улучшение дизайна кода, ремонтопригодность и расширяемость.Проще говоря, принципы SOLID действуют как принципы UX для разработчиков.

Q: Каковы 5 принципов ООП?

S – Принцип единой ответственности. O – Принцип открытости / закрытости. L – Принцип замещения Лискова. I – Принцип разделения интерфейса. D – Принцип инверсии зависимостей.

Q: Почему важны принципы SOLID?

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

Q: Кто изобрел принципы SOLID?

Эти принципы были впервые представлены Робертом Мартином в его статье 2000 года «Принципы дизайна и шаблоны дизайна». Позднее эти принципы были названы Майклом Фезерсом, который изменил их порядок, чтобы они могли образовать аббревиатуру SOLID.

Надежная архитектура для управления большими семантическими данными в реальном времени

Мигель А. Мартинес-Прието – доцент кафедры компьютерных наук Университета Вальядолида, Испания.Он защитил докторскую диссертацию. Он получил степень бакалавра компьютерных наук в том же университете в 2010 году. Его исследовательские интересы в основном связаны со сжатием данных и его применением для эффективного представления огромных наборов данных, управления ими и запросов к ним. Он является соавтором HDT, двоичного формата, признанного W3C для публикации и обмена огромными RDF в Web of Data.

Карлос Э. Куэста – адъюнкт-профессор Университета Рей Хуана Карлоса, Испания, где он также является заместителем декана факультета вычислительной техники. Он был сопредседателем программы Десятой рабочей конференции IEEE / IFIP и Шестой европейской конференции по архитектуре программного обеспечения (WICSA / ECSA 2012), а также председателем конференции для первого издания (ECSA 2007). Он также является активным членом Руководящего комитета ECSA. Он является одним из основателей исследовательской группы VorTIC3. Его основные исследовательские интересы связаны с архитектурой программного обеспечения и включают ориентацию на услуги, самоадаптирующиеся системы, отражение, облачные вычисления и параллелизм.

Марио Ариас – доктор философии.Кандидат наук в DERI Galway в Национальном университете Ирландии. Он получил степень магистра наук. по информационным технологиям и телекоммуникациям в Университете Вальядолида, а в настоящее время является членом подразделения промежуточного программного обеспечения датчиков в DERI Galway. Его текущее исследование сосредоточено на крупномасштабном управлении семантическими данными и руководит проектом с открытым исходным кодом RDF / HDT.

Хавьер Д. Фернандес – доктор философии. кандидат кафедры компьютерных наук Университета Вальядолида, Испания, и Университета Чили, Чили.Он начал свой двойной диплом благодаря гранту Erasmus Mundus в 2010 году. Он является соавтором заявки для участников HDT W3C, и его основные интересы включают масштабируемые представления и индексы для запросов к сети данных, сжатие данных и эффективное управление большими (семантическими) ) Данные.

Copyright © 2014 Elsevier B.V. Все права защищены.

Многоуровневая архитектура: надежный подход

Многоуровневая архитектура подвергается критике.

Несмотря на то, что это все еще самая распространенная архитектура, мы рассматриваем ее как антипаттерн.Он старый, не масштабируемый и несовместимый с SOLID. Он поощряет (вздрагивает) монолиты!

Да, знаю. Шестиугольная архитектура – лучший выбор. Или, может быть, я чувствую вкус к луку. Но только если он чистый!

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

Итак, давайте поговорим о слоях.

Это самая простая часть.Слои – это логические разделения в вашем коде. Компоненты сгруппированы в горизонтальные слои. Каждый слой выполняет определенную функцию.

Это не ярусы. И они не требуют, чтобы все слои были физически разделены. Кроме того, слои не заботятся о том, как организованы ваши файлы. (Хотя вы, вероятно, должны .)

Уровни разделяют различные обязанности вашего приложения.

Есть несколько нетривиальных преимуществ в организации вашей логической структуры по слоям.

• Ваш код будет легче понять. Поскольку это одна из наиболее широко используемых архитектур, каждый сталкивался с ней и может ей следовать. Язык, используемый для большинства слоев, можно понять без особых размышлений или объяснений.
• Этому шаблону легко следовать при написании новых функций. Вам не придется делать много умственной гимнастики, чтобы понять, как все взаимосвязано.
• Тестирование проще, поскольку каждый слой инкапсулирован и имеет модульную структуру.Любые вызовы за пределами текущего уровня должны использовать интерфейсы, что также упрощает имитацию в тестах.
• Ваше приложение легко расширить. Будь то добавление дополнительных компонентов или изменение существующих, есть простой шаблон, которому можно следовать.

См. Ниже изображение графа зависимостей NDepend, используемого для визуализации его собственного многоуровневого кода.

У подхода многоуровневой архитектуры есть недостатки.И некоторые его аспекты не были сочтены архитектурно чистыми для предметно-ориентированного проектирования.

Однако у большинства подходов есть недостатки. Главное – понимать как преимущества, так и недостатки. Выберите, какие архитектурные шаблоны лучше всего подходят для вашей конкретной проблемы.

Вот некоторые факторы, о которых следует помнить.

1. Многоуровневая архитектура очень ориентирована на базы данных. Как упоминалось ранее, поскольку все течет вниз, база данных часто оказывается последним слоем.Критики этой архитектуры отмечают, что ваше приложение не предназначено для хранения данных; это решение бизнес-задачи. Однако, когда так много приложений являются простыми приложениями CRUD, возможно, база данных – больше, чем просто вторичный игрок.
2. Масштабируемость может быть затруднена при многоуровневой архитектуре. Это связано с тем, что многие многоуровневые приложения, как правило, приобретают монолитные свойства. Если вам нужно масштабировать приложение, вы должны масштабировать целиком! Однако это не означает, что ваше многоуровневое приложение должно быть монолитом.Как только он станет достаточно большим, пришло время разделить его – как и с любой другой архитектурой.
3. Многоуровневое приложение сложнее развить, так как изменения требований часто затрагивают все уровни.
4. Многоуровневая архитектура развертывается как единое целое. Даже если он модульный и разделен на хорошие компоненты и пространства имен. Но это может быть неплохо. Если над разными частями приложения не работают отдельные команды, развертывание всех сразу – не самое худшее, что вы можете сделать.

Итак, вы решили использовать многоуровневую архитектуру. Что вы можете сделать, чтобы ваши проекты соответствовали принципам SOLID?

Убедитесь, что соблюдаете принцип единой ответственности

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

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

И компоненты состоят из подкомпонентов или классов. Так чего же им еще нужно придерживаться? Единичные обязанности!

Проверьте свое использование принципа открытого-закрытого

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

Убедитесь, что ваша иерархия соответствует принципу замещения Лискова

Согласно принципу подстановки Лискова, классы должны заменяться экземплярами своих подтипов без изменения функциональности. Теперь, как указывали другие здесь, этот ломается довольно часто!

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

Учитывайте своих клиентов, используя принцип разделения интерфейса

Итак, что будет дальше на нашем пути SOLID? Принцип разделения интерфейса гласит, что

Клиенты не должны зависеть от интерфейсов, которые они не используют.

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

Если все сделано правильно, при изменении контракта интерфейса нужно будет изменить только соседний слой.

И слегка обойти принцип инверсии зависимостей