Кратко про микросервисы на Scala и Erlang

Привет, Хабр!

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

В статье рассмотрим два языка программирования, которые выделяются своим функциональным подходом и широким применением в микросервисной архитектуре: Scala и Erlang.

Scala

Scala — это достаточной мощный ЯП, который сочетает в себе функциональные и объектно-ориентированные подходы.

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

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

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

Еще важно отметить, что Scala также имеет преимущества в интеграции с существующим Java-кодом, что делает его привлекательным выбором для компаний, уже имеющих код на Java.

Пример создания микросервиса на Scala

Прежде всего, установим Scala и необходимые зависимости. Также воспользуемся Akka HTTP для обработки HTTP запросов:

// build.sbt name := "microservice-example" version := "1.0" scalaVersion := "2.13.8"  libraryDependencies ++= Seq(   "com.typesafe.akka" %% "akka-actor-typed" % "2.6.17",   "com.typesafe.akka" %% "akka-stream" % "2.6.17",   "com.typesafe.akka" %% "akka-http" % "10.2.8",   "com.typesafe.akka" %% "akka-http-spray-json" % "10.2.8" )

Создадим актор для обработки запросов:

import akka.actor.typed.ActorSystem import akka.actor.typed.scaladsl.Behaviors  object Main extends App {   val system = ActorSystem(Behaviors.empty, "microservice")    // define actors and behavior here }

Создадим простой маршрут для API:

import akka.http.scaladsl.server.Directives._ import akka.http.scaladsl.server.Route  object Routes {   def helloRoute: Route =     path("hello") {       get {         complete("Hello, Habr!")       }     } }

Настроим HTTP сервер с использованием Akka HTTP:

import akka.http.scaladsl.Http import akka.actor.typed.scaladsl.adapter._  object Main extends App {   val system = ActorSystem(Behaviors.empty, "microservice")    val routes = Routes.helloRouter    Http().bindAndHandle(routes, "localhost", 8080)(system.toClassic) }

Запускаем:

object Main extends App {   val system = ActorSystem(Behaviors.empty, "microservice")    val routes = Routes.helloRoute // Add more routes as needed    Http().bindAndHandle(routes, "localhost", 8080)(system.toClassic)    println("Server online at http://localhost:8080/") }

Это базовый пример.

Scala также позволяет легко выполнять асинхронные HTTP запросы к внешним сервисам или микросервисам. Пример использования Akka HTTP Client для отправки GET запроса:

import akka.actor.ActorSystem import akka.http.scaladsl.Http import akka.http.scaladsl.model._ import scala.concurrent.Future import scala.util.{Success, Failure} import akka.stream.ActorMaterializer import scala.concurrent.ExecutionContext.Implicits.global  object HttpClientExample {   def main(args: Array[String]): Unit = {     implicit val system = ActorSystem()     implicit val materializer = ActorMaterializer()      val responseFuture: Future[HttpResponse] = Http().singleRequest(HttpRequest(uri = "http://example.com"))      responseFuture.onComplete {       case Success(response) =>         println(s"Request successful: $response")         // handle response       case Failure(ex) =>         println(s"Request failed: $ex")     }   } }

Scala позволяет создавать гибкие маршруты для обработки HTTP запросов с помощью Akka HTTP. Пример маршрута, который принимает POST запросы на путь /api/data и фильтрует запросы по определенным условиям:

import akka.http.scaladsl.server.Directives._ import akka.http.scaladsl.server.Route  object Routes {   def dataRoute: Route =     pathPrefix("api") {       path("data") {         post {           entity(as[String]) { requestData =>             // process the request data             complete("Data received: " + requestData)           }         }       }     } }

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

import akka.actor.typed.scaladsl.Behaviors import akka.actor.typed.{ActorRef, ActorSystem, Behavior}  object StateManagement {   // define messages   sealed trait Command   case class UpdateState(data: String) extends Command   case class GetState(replyTo: ActorRef[String]) extends Command    // define actor behavior   def stateManager(state: String): Behavior[Command] =     Behaviors.receiveMessage {       case UpdateState(data) =>         stateManager(data)       case GetState(replyTo) =>         replyTo ! state         Behaviors.same     }    def main(args: Array[String]): Unit = {     val system = ActorSystem(stateManager("Initial state"), "state-manager")      val stateManagerRef = system       .unsafeUpcast[StateManagement.Command]       .narrow      stateManagerRef ! GetState(System.out)   } }

Erlang

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

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

И самое главное — Erlang изначально разработан для построения распределенных систем.

Реализация

GenServer является базой для создания микросервисов на Erlang. Он обеспечивает асинхронное взаимодействие и управление состоянием:

-module(example_service). -behaviour(gen_server).  %% API -export([start_link/0, get_state/1]).  %% Callbacks -export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).  %% State -record(state, {data = []}).  %% API functions start_link() ->     gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).  get_state(Pid) ->     gen_server:call(Pid, get_state).  %% Callback functions init([]) ->     {ok, #state{}}.  handle_call(get_state, _From, State) ->     {reply, State#state.data, State}.  handle_cast(_Msg, State) ->     {noreply, State}.  handle_info(_Info, State) ->     {noreply, State}.  terminate(_Reason, _State) ->     ok.  code_change(_OldVsn, State, _Extra) ->     {ok, State}.

Supervisor обеспечивает отказоустойчивость и перезапуск микросервисов в случае сбоев:

-module(example_supervisor).  -behaviour(supervisor).  %% API -export([start_link/0]).  %% Callbacks -export([init/1]).  %% Init function start_link() ->     supervisor:start_link({local, ?MODULE}, ?MODULE, []).  %% Callback function init([]) ->     {ok, {{one_for_one, 5, 10},           [{example_service, {example_service, start_link, []},             permanent, 5000, worker, [example_service]}]}}.

Развернем на кластере:

%% запуска микросервиса на удаленном узле start_remote_service(Node) ->     {ok, _} = net_kernel:start([example@hostname]),     {ok, _} = rpc:call(Node, example_service, start_link, []).

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

%% запуск дополнительных экземпляров микросервиса на разных узлах кластера start_additional_instances(NumInstances, Node) ->     lists:foreach(fun(_) -> start_remote_service(Node) end, lists:seq(1, NumInstances)).

Определяем функцию start_additional_instances, которая принимает два аргумента: NumInstances, представляющий собой количество дополнительных экземпляров микросервиса, которые хотим запустить, и Node, представляющий собой имя узла кластера, на котором мы хотим развернуть эти экземпляры.

Затем используем функцию lists:seq/2, чтобы сгенерировать список чисел от 1 до NumInstances. Далее используем функцию lists:foreach/2, чтобы выполнить функцию start_remote_service для каждого элемента списка.

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