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 или очереди сообщений и другими важными аспектами для реализации микросервисной архитектуры.

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

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