Микросервисные приложения на GoMicro

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

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

• Аутентификация и авторизация обеспечивают для каждого сервиса идентификатор и сертификаты и реализует управление доступом на основе правил.

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

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

• Механизм обнаружения сервисов — автоматическая регистрация сервисов и разрешение имен (по умолчанию на основе mDNS).

• Балансировка нагрузки — балансировка нагрузки на стороне клиента, основанная на обнаружении сервисов. Нагрузка распределяется равномерно между несколькими реализациями сервисами с автоматическим переключением при наличии ошибок.

• Кодирование сообщений — возможность кодирования сообщений в JSON / Protobuf.

• Клиент/сервер RPC — запрос/ответ на основе RPC с поддержкой двунаправленной потоковой передачи.

• Асинхронный обмен сообщениями — PubSub является основой для распределенных приложений, управляемых событиями (на основе HTTP-запросов).

• Потоковая передача событий реализует поддержку потоков NATS Jetstream и Redis.

• Синхронизация. Поддерживается распределенная блокировка и протокол динамического выбора лидера среди доступного кворума.

• Подключаемые интерфейсы — Go Micro использует интерфейсы Go для каждой абстракции распределенной системы и позволяет создавать собственные реализации для каждого компонента.

Для подключения GoMicro нужно установить и импортировать модуль из «go-micro.dev/v4» и дальше использовать его методы для управления создаваемым сервисом. Также в модулях в github.com/go-micro/plugins/v4/… доступны плагины, которых делятся на следующие категории:

• broker — взаимодействие с брокерами сообщений для реализации потоковой передачи сообщений (NATS, RabbitMQ, Kafka)

• client — клиенты для запросов к другим микросервисам (через RPC, gRPC или HTTP)

• server — серверный компонент для обеспечения доступа к микросервису (RPC, gRPC, HTTP)

• codec — кодирование сообщений в BSON, Mercury, Protobuf

• config — управление распределенной конфигурацией

• registry — регистрация и обнаружение сервисов (в том числе, может взаимодействовать с Kubernetes)

• selector — балансировка нагрузки

• transport — двухсторонняя передача данных через NATS или RabbitMQ

• wrapper — дополнительные middleware (например, логирование, трассировка запросов, ограничение скорости запросов и т.д.)

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

package main  import ( "go-micro.dev/v4"   "github.com/go-micro/plugins/v4/registry/kubernetes"   grpcc "github.com/go-micro/plugins/v4/client/grpc" grpcs "github.com/go-micro/plugins/v4/server/grpc" )  func main() {     registry := kubernetes.NewRegistry() service := micro.NewService( micro.Name("my.service"),         micro.Registry(registry),         micro.Server(grpcs.NewServer()), micro.Client(grpcc.NewClient()), )     service.Server().handle() service.Init()     service.Run() }

Далее для реализации обработчиков и вызовов удаленных методов могут использоваться механизмы кодогенерации для protobuf (protoc-gen-go), для доступа к зарегистрированным компонентам используются методы в service. Например, для получения доступа к объекту сервера можно обратиться к service.Server(), аналогично для подключения к сгенерированному клиенту service.Client() и т.д. При наличии proto-файла и сгенерированного описания методов и протокола взаимодействия с микросервисом, вызов может выглядеть следующим образом (в pb импортирован структура, сгенерированная protoc-gen-go)

if err := pb.RegisterPaymentServiceHandler(srv.Server(), new(handler.PaymentService)); err != nil { logger.Fatal(err) }

При этом сам proto-файл описывает все аспекты взаимодействия с микросервисом и определяет дополнительные типы данных (перечисления, структуры и др.), например:

syntax = "proto3";  package shop;  option go_package = "./proto;shop";  service Health {   rpc Check(HealthCheckRequest) returns (HealthCheckResponse) {}   rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse) {} }  message HealthCheckRequest {  string service = 1; }  message HealthCheckResponse {   enum ServingStatus {     UNKNOWN = 0;     SERVING = 1;     NOT_SERVING = 2;     SERVICE_UNKNOWN = 3;   }   ServingStatus status = 1; }

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

package main  import ( "fmt"  "context" "go-micro.dev/v4" )  func pub(i int, p micro.Publisher) { msg := &Message{ Say: fmt.Sprintf("This is an async message %d", i), }  if err := p.Publish(context.TODO(), msg); err != nil { fmt.Println("pub err: ", err) return }  fmt.Printf("Published %d: %v\n", i, msg) }  func main() { service := micro.NewService() service.Init()  p := micro.NewPublisher("example", service.Client())  for i := 0; i < 10; i++ { pub(i, p) } }

Аналогично можно создавать распределенные конфигурации, обнаруживать сервисы (через registry), создавать клиентов RPC, подписываться на появление сообщений в очередях RabbitMQ/Kafka. Также доступны механизмы для конфигурирования heartbeat (для проверки доступности и корректного функционирования сервисов):

service := micro.NewService( micro.Name("payment"),   micro.RegisterInterval(time.Second*30), micro.RegisterTTL(time.Second*120), )

Дополнительно можно подключать собственные расширения с использованием micro.WrapHandler:

import (     "log" "go-micro.dev/v4" "go-micro.dev/v4/server" )  func logWrapper(fn server.HandlerFunc) server.HandlerFunc { return func(ctx context.Context, req server.Request, rsp interface{}) error { log.Printf("[request]: %v", req.Endpoint()) err := fn(ctx, req, rsp) return err } }  func main() { service := micro.NewService( micro.Name("greeter"), // wrap the handler micro.WrapHandler(logWrapper), )  service.Init()  proto.RegisterHandler(service.Server(), new(PaymentService))  if err := service.Run(); err != nil { fmt.Println(err) } }

Для мониторинга запущенных микросервисов может использоваться GoMicro Dashboard, который может быть установлен через go install github.com/go-micro/dashboard@latest.

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

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

• Зарегистрироваться на бесплатный урок