Салют, Хабр!

Go Kit предоставляет стандартизированный способ создания сервисов, с ее помощью можно легко реализовать совместимость сервисов. С его помощью можно легко интегрировать различные транспортные протоколы, такие как HTTP, RPC, gRPC, и многое другое, а также реализовывать общие паттерны: логирование, метрики, трассировка. В общем, Go Kit хорошо подходит для разработки микросервисов на go.

Мотивацию создания этой либы разработчики описали так:

Go стал языком сервера, но он по-прежнему недостаточно представлен в так называемых «современных корпоративных» компаниях, таких как Facebook, Twitter, Netflix и SoundCloud. Многие из этих организаций обратились к стекам на основе JVM для создания своей бизнес-логики, во многом благодаря библиотекам и экосистемам, которые напрямую поддерживают их микросервисные архитектуры.

Чтобы достичь следующего уровня успеха, Go нужно нечто большее, чем простые примитивы и идиомы. Ему нужен всеобъемлющий набор инструментов для последовательного распределенного программирования в целом. Go Kit — это набор пакетов и лучших практик, которые обеспечивают комплексный, надежный и надежный способ создания микросервисов для организаций любого размера.

Также стоит упомянуть, что разработчики не ставят цель реализовать следующие функции:

• Поддержка шаблонов обмена сообщениями, отличных от RPC (на данный момент), например MPI, pub/sub, CQRS и т. д.

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

Установка Go Kit:

go get -u github.com/go-kit/kit

Go Kit требует Go версии 1.13 или выше.

Компоненты Go Kit

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

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

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

Основные функции

Сервисный слой

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

Допустим нужен микросервис для управления пользователями. На уровне интерфейса это может выглядеть так:

package userservice

// userService определяет интерфейс для нашего сервиса управления пользователями.
type UserService interface {
    CreateUser(name string, email string) (User, error)
    GetUser(id string) (User, error)
}

UserService предоставляет две операции: CreateUser для создания нового пользователя и GetUser для получения информации о пользователе по его идентификатору. Возвращаемые значения и ошибки указывают на результат выполнения каждой операции.

После определения интерфейса следующим шагом будет реализация этого интерфейса. Реализация — это конкретный код, который выполняет логику, описанную интерфейсом:

package userservice

import "errors"

// userService представляет реализацию нашего UserService.
type userService struct {
    // здесь различные зависимости, ссылки на бд и т.п
}

// NewUserService создает и возвращает новый экземпляр userService.
func NewUserService() UserService {
    return &userService{}
}

// CreateUser реализует логику создания пользователя.
func (s *userService) CreateUser(name string, email string) (User, error) {
    // логика создания нового пользователя.
    // проверка валидности данных и запись пользователя в базу данных
    return User{Name: name, Email: email}, nil
}

// GetUser реализует логику получения пользователя по ID.
func (s *userService) GetUser(id string) (User, error) {
    // логика поиска пользователя по его ID в базе данных.
    // если пользователь не найден, возвращается ошибка.
    return User{}, errors.New("user not found")
}

// ser представляет модель пользователя в нашей системе.
type User struct {
    ID    string
    Name  string
    Email string
}

userService является приватной структурой, которая реализует интерфейс UserService. ФункцияNewUserServiceнужно чтобы скрыть детали создания экземпляра сервиса и возвращаем интерфейс, а не конкретный тип.

Endpoint слой

Допустим, у нас есть сервис UserService с методом GetUser, который мы хотим экспонировать через HTTP. Сначала определим endpoint:

import (
    "context"
    "github.com/go-kit/kit/endpoint"
)

// GetUserRequest определяет структуру запроса к endpoint.
type GetUserRequest struct {
    UserID string
}

// GetUserResponse определяет структуру ответа от endpoint.
type GetUserResponse struct {
    User  User   `json:"user,omitempty"`
    Err   string `json:"err,omitempty"` // ошибки не сериализуются по JSON напрямую.
}

// MakeGetUserEndpoint создает endpoint для метода GetUser сервиса UserService.
func MakeGetUserEndpoint(svc UserService) endpoint.Endpoint {
    return func(ctx context.Context, request interface{}) (interface{}, error) {
        req := request.(GetUserRequest)
        user, err := svc.GetUser(req.UserID)
        if err != nil {
            return GetUserResponse{User: user, Err: err.Error()}, nil
        }
        return GetUserResponse{User: user, Err: ""}, nil
    }
}

Крейтнули endpoint, который принимает запрос GetUserRequest, извлекает UserID и использует его для вызова метода GetUser нашего сервиса UserService. Ответ от сервиса затем оборачивается в GetUserResponse.

Middleware позволяет добавлять перехватывающую логику в обработку запросов, например, для логирования, мониторинга, проверки аутентификации и т.д., не изменяя логику самих endpoints.

Проще говоря, middleware представляет собой функцию, которая принимает endpoint и возвращает другой endpoint:

import (
    "context"
    "github.com/go-kit/kit/endpoint"
    "github.com/go-kit/kit/log"
)

// LoggingMiddleware возвращает Middleware, которое логирует запросы к сервису.
func LoggingMiddleware(logger log.Logger) endpoint.Middleware {
    return func(next endpoint.Endpoint) endpoint.Endpoint {
        return func(ctx context.Context, request interface{}) (response interface{}, err error) {
            logger.Log("msg", "calling endpoint")
            response, err = next(ctx, request)
            logger.Log("msg", "called endpoint")
            return
        }
    }
}

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

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

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

type ProfileService interface {
    CreateProfile(ctx context.Context, profile Profile) (string, error)
    GetProfile(ctx context.Context, id string) (Profile, error)
}

Для каждого метода интерфейса сервиса определим соответствующий endpoint.

func makeCreateProfileEndpoint(svc ProfileService) endpoint.Endpoint {
    return func(ctx context.Context, request interface{}) (interface{}, error) {
        req := request.(createProfileRequest)
        id, err := svc.CreateProfile(ctx, req.Profile)
        return createProfileResponse{ID: id, Err: err}, nil
    }
}

func makeGetProfileEndpoint(svc ProfileService) endpoint.Endpoint {
    return func(ctx context.Context, request interface{}) (interface{}, error) {
        req := request.(getProfileRequest)
        profile, err := svc.GetProfile(ctx, req.ID)
        return getProfileResponse{Profile: profile, Err: err}, nil
    }
}

Теперь есть несколько endpoints, их можно группировать вместе. Это обычно делается путем создания структуры, которая содержит все эти endpoints как поля:

type Endpoints struct {
    CreateProfile endpoint.Endpoint
    GetProfile    endpoint.Endpoint
}

func MakeEndpoints(svc ProfileService) Endpoints {
    return Endpoints{
        CreateProfile: makeCreateProfileEndpoint(svc),
        GetProfile:    makeGetProfileEndpoint(svc),
    }
}

Структура Endpoints теперь агрегирует все endpoints, связанные с ProfileService, вроде - удобно.

После группировки endpoints их можно использовать в транспортном слое (про транспортные слое чуть ниже). Например, при создании HTTP сервера, можно ссылаться на эти endpoints напрямую из структуры Endpoints:

func NewHTTPHandler(endpoints Endpoints) http.Handler {
    r := mux.NewRouter()

    r.Methods("POST").Path("/profiles").Handler(httptransport.NewServer(
        endpoints.CreateProfile,
        decodeHTTPCreateProfileRequest,
        encodeHTTPGenericResponse,
    ))

    r.Methods("GET").Path("/profiles/{id}").Handler(httptransport.NewServer(
        endpoints.GetProfile,
        decodeHTTPGetProfileRequest,
        encodeHTTPGenericResponse,
    ))

    return r
}

Транспортный слой

Для создания HTTP сервера определяются транспортные функции, которые преобразуют HTTP запросы в вызовы вашего сервиса и ответы сервиса обратно в HTTP ответы:

package main

import (
    "context"
    "encoding/json"
    "net/http"
    "github.com/go-kit/kit/endpoint"
    "github.com/go-kit/kit/transport/http"
)

// сервис
type MyService interface {
    Add(a, b int) int
}

type myService struct{}

func (myService) Add(a, b int) int { return a + b }

// endpoint
func makeAddEndpoint(svc MyService) endpoint.Endpoint {
    return func(ctx context.Context, request interface{}) (interface{}, error) {
        req := request.(addRequest)
        v := svc.Add(req.A, req.B)
        return addResponse{V: v}, nil
    }
}

type addRequest struct {
    A int `json:"a"`
    B int `json:"b"`
}

type addResponse struct {
    V int `json:"v"`
}

// decode и encode функции
func decodeAddRequest(_ context.Context, r *http.Request) (interface{}, error) {
    var request addRequest
    if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
        return nil, err
    }
    return request, nil
}

func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
    return json.NewEncoder(w).Encode(response)
}

func main() {
    svc := myService{}

    addEndpoint := makeAddEndpoint(svc)
    addHandler := http.NewServer(addEndpoint, decodeAddRequest, encodeResponse)

    http.Handle("/add", addHandler)
    http.ListenAndServe(":8080", nil)
}

Создаем простой сервис MyService с методом Add, который складывает два числа. Затем создается endpoint, который обрабатывает логику преобразования запросов и ответов. Для обработки HTTP запросов и ответов используем http.NewServer.

Для создания HTTP клиента используется аналогичная абстракция:

package main

import (
    "context"
    "encoding/json"
    "net/http"
    "github.com/go-kit/kit/endpoint"
    "github.com/go-kit/kit/transport/http"
)

func makeHTTPClient(baseURL string) MyService {
    var addEndpoint endpoint.Endpoint
    addEndpoint = http.NewClient(
        "POST",
        mustParseURL(baseURL+"/add"),
        encodeHTTPRequest,
        decodeHTTPResponse,
    ).Endpoint()

    return Endpoints{AddEndpoint: addEndpoint}
}

func encodeHTTPRequest(_ context.Context, r *http.Request, request interface{}) error {
    // код для кодирования запроса
}

func decodeHTTPResponse(_ context.Context, resp *http.Response) (interface{}, error) {
    var response addResponse
    if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
        return nil, err
    }
    return response, nil
}

Go Kit предлагает встроенную поддержку для gRPC:

Определим интерфейс сервиса и структуры данных, которые он использует, в .proto файле. fe:

syntax = "proto3";

package example;

service StringService {
  rpc Uppercase (UppercaseRequest) returns (UppercaseResponse) {}
  rpc Count (CountRequest) returns (CountResponse) {}
}

message UppercaseRequest {
  string str = 1;
}

message UppercaseResponse {
  string str = 1;
  string err = 2;
}

message CountRequest {
  string str = 1;
}

message CountResponse {
  int32 count = 1;
}

Используя protoc компилятор с плагином для Go, можно сгенерировать Go код, который будет использоваться для создания gRPC сервера:

protoc --go_out=. --go-grpc_out=. path/to/your_service.proto

Далее реализуем сервис в Go, используя интерфейсы, сгенерированные из .proto файла:

package main

import (
    "context"
    "strings"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
    pb "path/to/your_service_package"
)

type stringService struct {
    pb.UnimplementedStringServiceServer
}

func (s *stringService) Uppercase(ctx context.Context, req *pb.UppercaseRequest) (*pb.UppercaseResponse, error) {
    if req.Str == "" {
        return nil, status.Errorf(codes.InvalidArgument, "Empty string")
    }
    return &pb.UppercaseResponse{Str: strings.ToUpper(req.Str)}, nil
}

func (s *stringService) Count(ctx context.Context, req *pb.CountRequest) (*pb.CountResponse, error) {
    return &pb.CountResponse{Count: int32(len(req.Str))}, nil
}

run:

package main

import (
    "log"
    "net"
    "google.golang.org/grpc"
    pb "path/to/your_service_package"
)

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    var opts []grpc.ServerOption
    grpcServer := grpc.NewServer(opts...)
    pb.RegisterStringServiceServer(grpcServer, newStringService())
    grpcServer.Serve(lis)
}

Здесь так же как и в эндпоинтах есть Middleware, который в транспортном слое позволяет встраивать дополнительную логику обрабтки для входящих и исходящих запросов/ответов:

package main

import (
    "context"
    "fmt"
    "github.com/go-kit/kit/endpoint"
    "github.com/go-kit/log"
)

// LoggingMiddleware возвращает Middleware, которое логирует детали запроса
func LoggingMiddleware(logger log.Logger) endpoint.Middleware {
    return func(next endpoint.Endpoint) endpoint.Endpoint {
        return func(ctx context.Context, request interface{}) (response interface{}, err error) {
            logger.Log("msg", "calling endpoint")
            defer func() {
                logger.Log("msg", "called endpoint", "err", err)
            }()
            return next(ctx, request)
        }
    }
}

Прочие возможности

В го кит есть абстракция логирования, которая позволяет легко интегрировать любую систему логирования с вашими сервисами. Например, мой любимыйlog.Logger, который отличается своей минималистичностью:

import (
    "github.com/go-kit/log"
    "github.com/sirupsen/logrus"
)

type logrusLogger struct {
    *logrus.Logger
}

func (l logrusLogger) Log(keyvals ...interface{}) error {
    // здесь может быть реализация адаптация аргументов keyvals
    // для logrus или другой логики адаптации.
    l.Logger.WithFields(logrus.Fields{"keyvals": keyvals}).Info()
    return nil
}

// экземпляр Logger Go Kit, используя logrus
logger := logrusLogger{logrus.New()}

Можно интегрироваться с системами метрик, к примеру с Prometheus:

import (
    "github.com/go-kit/kit/metrics/prometheus"
    stdprometheus "github.com/prometheus/client_golang/prometheus"
)

var requestCount = prometheus.NewCounterFrom(stdprometheus.CounterOpts{
    Namespace: "my_namespace",
    Subsystem: "my_subsystem",
    Name:      "request_count",
    Help:      "Number of requests received.",
}, []string{"method"})

Можно интегрироваться с системами трассировки, к примеру Jaeger:

import (
    "github.com/go-kit/kit/tracing/opentracing"
    "github.com/opentracing/opentracing-go"
    "github.com/uber/jaeger-client-go/config"
)

// сеттинги Jaeger
cfg, _ := config.FromEnv()
tracer, _, _ := cfg.NewTracer()

// трассировка в endpoint
tracedEndpoint := opentracing.TraceServer(tracer, "my_endpoint")(myEndpoint)

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

import (
    "errors"
    "net/http"
    "github.com/go-kit/kit/transport/http"
)

var ErrInvalidArgument = errors.New("invalid argument")

// прнбразование ошибки в HTTP статус
errorEncoder := func(ctx context.Context, err error, w http.ResponseWriter) {
    code :=

 http.StatusInternalServerError
    if err == ErrInvalidArgument {
        code = http.StatusBadRequest
    }
    w.WriteHeader(code)
    json.NewEncoder(w).Encode(map[string]interface{}{
        "error": err.Error(),
    })
}

Таким образом с go kit можно решить типичные проблемы в распределенных системах и архитектуре приложений. Go Kit на гитхабе, сайт Go Kit

Статья подготовлена в преддверии старта курса "Microservice Architecture" от OTUS.