Лучший фреймворк Golang для микросервисов: GoFr
Go – это мультипарадигмальный, статически типизированный и компилируемый язык программирования, разработанный компанией Google. Многие разработчики приняли Go благодаря его функции сбора мусора, безопасности памяти и структурной системе типизации. Веб-фреймворки Go были созданы для того, чтобы облегчить процесс веб-разработки на Go, не заботясь о настройках и уделяя больше внимания функциональности проекта. При создании небольших приложений фреймворки могут быть не нужны, но для программного обеспечения производственного уровня они крайне важны. Фреймворки предоставляют дополнительные функции и сервисы, которые могут быть использованы другими разработчиками, желающими добавить аналогичные функции в свое программное обеспечение, вместо того чтобы писать полноценное программное обеспечение самостоятельно.
Выбор правильного фреймворка для ваших нужд может ускорить циклы разработки и упростить сопровождение в дальнейшем. В этой статье мы расскажем о GoFr, фреймворке на языке Golang для ускоренной разработки микросервисов. И мы узнаем, почему он является вашим лучшим выбором при создании микросервисов на Go!
GoFr и его богатый набор функций
Что действительно делает фреймворк хорошим или плохим, так это простота разработки, которую он предоставляет пользователю, а также набор функций, которые он предлагает, чтобы пользователь мог сосредоточиться исключительно на реализации логики. GoFr был создан для того, чтобы помочь разработчикам писать быстрые, масштабируемые и эффективные API. Фреймворк предлагает богатый набор функций, которые помогают разработчикам с легкостью писать микросервисы производственного уровня. Давайте рассмотрим некоторые из этих возможностей:
Эффективное управление конфигурациями
Переменные окружения – лучший способ задать значения конфигурации для вашего программного приложения, поскольку они могут быть определены на системном уровне, независимо от программного обеспечения. Это один из принципов методологии Twelve-Factor App, позволяющий создавать приложения с возможностью переноса.
В GoFr есть несколько предопределенных переменных окружения для различных целей, таких как изменение уровня журнала, подключение к базам данных, установка имени и версии приложения, установка http-портов и т. д. Пользователю достаточно задать их в файле .env в каталоге configs приложения, и GoFr автоматически считывает значения из этого файла.
Вот полный список переменных окружения, поддерживаемых GoFr:
Бесшовное взаимодействие с базами данных
Управление соединениями и взаимодействием с базами данных может стать суматохой, особенно при работе с несколькими базами данных. GoFr легко справляется с соединениями с базами данных, используя переменные конфигурации. Он не только управляет соединениями, но и обеспечивает прямой доступ к объектам базы данных, используя контекст GoFr в обработчиках. Такой подход упрощает работу с несколькими базами данных. В настоящее время GoFr поддерживает все диалекты SQL, базы данных Redis, MongoDB, Cassandra и ClickHouse.
Пример использования БД MySQL и Redis внутри обработчика:
func DBHandler(c *gofr.Context) (interface{}, error) {
var value int
// querying a SQL db
err := c.SQL.QueryRowContext(c, "select 2+2").Scan(&value)
if err != nil {
return nil, datasource.ErrorDB{Err: err, Message: "error from sql db"}
}
// retrieving value from Redis
_, err = c.Redis.Get(c, "test").Result()
if err != nil && !errors.Is(err, redis.Nil) {
return nil, datasource.ErrorDB{Err: err, Message: "error from redis db"}
}
return value, nil
}Легкая реализация архитектуры Издатель-Подписчик
GoFr упрощает архитектуру Pub/Sub, предлагая встроенную поддержку таких популярных клиентов, как Kafka, Google Pub/Sub и MQTT. Это устраняет необходимость в ручной настройке или управлении библиотеками, позволяя сосредоточиться на архитектуре, ориентированной на события. Публикация и подписка на события упрощаются с помощью контекста GoFr. Публикация событий может быть выполнена внутри обработчика с использованием контекста, а для подписки на событие достаточно использовать обработчик Subscribe от GoFr. Такой подход способствует чистоте кода и уменьшает количество шаблонов по сравнению с реализацией паттерна Pub/Sub с нуля.
Пример реализации архитектуры Издателя и Подписчика в приложении GoFr:
package main
import (
"encoding/json"
"gofr.dev/pkg/gofr"
)
func main() {
app := gofr.New()
app.POST("/publish-product", product)
// subscribing to products topic
app.Subscribe("products", func(c *gofr.Context) error {
var productInfo struct {
ProductId string `json:"productId"`
Price string `json:"price"`
}
err := c.Bind(&productInfo)
if err != nil {
c.Logger.Error(err)
return nil
}
c.Logger.Info("Received product ", productInfo)
return nil
})
app.Run()
}
func product(ctx *gofr.Context) (interface{}, error) {
type productInfo struct {
ProductId string `json:"productId"`
Price string `json:"price"`
}
var data productInfo
// binding the request data to productInfo struct
err := ctx.Bind(&data)
if err != nil {
return nil, err
}
msg, _ := json.Marshal(data)
// publishing message to producst topic using gofr context
err = ctx.GetPublisher().Publish(ctx, "products", msg)
if err != nil {
return nil, err
}
return "Published", nil
}Наблюдаемость из коробки
Эффективный мониторинг имеет решающее значение для поддержания высокопроизводительных микросервисов. GoFr снимает это бремя с ваших плеч, предоставляя встроенные функции наблюдаемости. Это устраняет необходимость ручной настройки библиотек трассировки, метрик и протоколирования.
Подробное протоколирование
GoFr предлагает структурированную запись событий с различными уровнями журнала (INFO, DEBUG, WARN, ERROR, FATAL), чтобы фиксировать события приложения с разной степенью детализации. Это позволяет анализировать поток приложений, выявлять потенциальные проблемы и упрощать отладку.
Действенные показатели
GoFr автоматически собирает и отображает метрики приложения, позволяя отслеживать ключевые показатели производительности. Благодаря доступным метрикам можно быстро выявить уязвимые места и оптимизировать работу приложения.
Распределенная трассировка
GoFr интегрируется с такими популярными бэкендами трассировки, как Zipkin и Jaeger. Распределенная трассировка позволяет визуализировать весь жизненный цикл запроса в микросервисах, что облегчает выявление первопричины проблем в сложных системах.
Эффективная межсервисная HTTP-связь
В архитектуре микросервисов эффективная и надежная связь между сервисами имеет решающее значение. GoFr упрощает этот процесс, предоставляя специальный механизм для инициализации и управления межсервисной HTTP-связью. Вы можете легко зарегистрировать нижележащие сервисы на уровне приложения с помощью метода AddHTTPService.
Эти функции наблюдения помогают пользователям получить подробное представление о потоке и производительности приложения, выявить и устранить узкие места и обеспечить бесперебойную работу.
Параметры конфигурации для HTTP-сервисов
GoFr предлагает множество вариантов конфигурации для улучшения межсервисного взаимодействия:
- Аутентификация: Поддерживает APIKeyConfig, BasicAuthConfig и OAuthConfig для безопасной аутентификации.
- Заголовки по умолчанию: Позволяет задавать заголовки по умолчанию для всех последующих запросов к HTTP-сервисам.
- Прерыватель цепи: Повысьте устойчивость сервиса с помощью встроенной функции прерывания цепи. GoFr позволяет настраивать пороговые значения и интервалы для изящной обработки сбоев и предотвращения каскадных отказов.
- Проверка состояния: Проактивно следите за состоянием нижележащих служб, используя конфигурацию проверок здоровья GoFr. Определите конечную точку здоровья для каждой службы, и GoFr будет автоматически проверять их доступность, позволяя обнаружить потенциальные проблемы на ранней стадии.
Эти функции обеспечивают безопасность, надежность и простоту управления межсервисным взаимодействием.
Пример подключения к HTTP-сервису и отправки GET-запроса:
func main() {
a := gofr.New()
a.AddHTTPService("cat-facts", "https://catfact.ninja",
&service.CircuitBreakerConfig{
Threshold: 4,
Interval: 1 * time.Second,
},
&service.HealthConfig{
HealthEndpoint: "breeds",
},
)
a.GET("/fact", Handler)
a.Run()
}
func Handler(c *gofr.Context) (any, error) {
var data = struct {
Fact string `json:"fact"`
Length int `json:"length"`
}{}
var catFacts = c.GetHTTPService("cat-facts")
resp, err := catFacts.Get(c, "fact", map[string]interface{}{
"max_length": 20,
})
if err != nil {
return nil, err
}
b, _ := io.ReadAll(resp.Body)
err = json.Unmarshal(b, &data)
if err != nil {
return nil, err
}
return data, nil
}Гибкая поддержка промежуточного программного обеспечения для расширенного контроля
Промежуточное ПО позволяет перехватывать и манипулировать HTTP-запросами и ответами, проходящими через маршрутизатор вашего приложения. Промежуточное ПО может выполнять такие задачи, как аутентификация, авторизация, кэширование и т. д. до или после того, как запрос достигнет обработчика вашего приложения.
GoFr предоставляет разработчикам поддержку промежуточного ПО, позволяя манипулировать запросами/ответами и внедрять пользовательскую логику. Это дает мощный механизм для модульной и многоразовой реализации таких сквозных задач, как аутентификация, авторизация и кэширование. Функции промежуточного ПО регистрируются с помощью метода UseMiddleware в вашем приложении GoFr. Кроме того, GoFr включает встроенное промежуточное ПО CORS (Cross-Origin Resource Sharing) для обработки заголовков, связанных с CORS.
Пример добавления пользовательского промежуточного ПО в приложение GoFr:
import (
"net/http"
gofrHTTP "gofr.dev/pkg/gofr/http"
)
// Define your custom middleware function
func customMiddleware() gofrHTTP.Middleware {
return func(inner http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Your custom logic here
// For example, logging, authentication, etc.
// Call the next handler in the chain
inner.ServeHTTP(w, r)
})
}
}
func main() {
// Create a new instance of your GoFr application
app := gofr.New()
// Add your custom middleware to the application
app.UseMiddleware(customMiddleware())
// Define your application routes and handlers
// ...
// Run your GoFr application
app.Run()
}Встроенные механизмы аутентификации
Обеспечение безопасности микросервисов с помощью надежной аутентификации имеет решающее значение. GoFr упрощает этот процесс, предоставляя встроенную поддержку различных стандартных механизмов аутентификации. Это позволяет вам выбрать подход, который наилучшим образом соответствует потребностям вашего приложения, без написания сложной логики аутентификации с нуля.
Базовая авторизация
Базовая авторизация – это самый простой способ аутентификации API. Она построена на схеме аутентификации протокола HTTP. Он предполагает отправку префикса Basic, сопровождаемого Base64-кодировкой в стандартном заголовке Authorization. GoFr предлагает два способа реализации базовой авторизации: использование предопределенных учетных данных и определение пользовательской функции проверки.
API-ключи для авторизации
Аутентификация по API-ключам – это схема HTTP-аутентификации, при которой уникальный API-ключ включается в заголовок запроса для проверки на соответствие хранилищу авторизованных ключей. GoFr предлагает два способа реализации аутентификации по API-ключам: проверка фреймворка по умолчанию, а также определение пользовательской функции проверки.
OAuth 2.0
OAuth 2.0 – это стандартный протокол для авторизации. Он ориентирован на простоту для разработчиков клиентов, обеспечивая при этом специальные потоки авторизации для веб-приложений, настольных приложений, мобильных телефонов и устройств для гостиной. Он предполагает отправку префикса Bearer, за которым следует закодированный токен в стандартном заголовке Authorization. GoFr поддерживает аутентификацию токенов, закодированных по алгоритму RS256/384/512.
Обратитесь к документации по аутентификации GoFr, чтобы увидеть примеры использования этих механизмов аутентификации и узнать о них больше.
Автоматическая рендеринг пользовательского интерфейса Swagger
Предоставление понятной и интерактивной документации по API необходимо для принятия пользователями и эффективного рабочего процесса разработки. Спецификации API могут быть написаны в формате YAML или JSON. Этот формат прост в освоении и доступен для чтения как людям, так и машинам. Полную спецификацию OpenAPI можно найти на официальном сайте Swagger.
GoFr поддерживает автоматическое отображение документации OpenAPI (также известной как Swagger). Эта функция позволяет вам легко предоставлять интерактивную документацию по API для ваших пользователей. Чтобы позволить GoFr отрисовывать документацию OpenAPI, просто поместите файл openapi.json в статический каталог вашего проекта. GoFr автоматически отобразит документацию Swagger в конечной точке /.well-known/swagger.
Заключение
В этой статье мы рассмотрели богатые возможности GoFr, фреймворка Golang, разработанного специально для ускорения разработки микросервисов. Мы увидели, как GoFr упрощает такие распространенные задачи, как управление конфигурацией, взаимодействие с базами данных, интеграция Pub/Sub, автоматическая наблюдаемость, межсервисное взаимодействие, использование промежуточного ПО и аутентификация. Кроме того, GoFr предлагает встроенную поддержку миграции данных, веб-сокетов, заданий cron и удаленного изменения уровня журнала, что еще больше упрощает процесс разработки.
Мы провели сравнение GoFr с другими популярными Go-фреймворками, такими как Gin, Chi, Echo и Fiber, и обнаружили, что GoFr показал оптимальные результаты, даже несмотря на свой обширный набор функций. Это означает, что вы можете использовать все его мощные функциональные возможности без ущерба для производительности.
Мы рекомендуем вам самим изучить GoFr. Исчерпывающая документация по фреймворку, учебные пособия и активное сообщество – это ценные ресурсы, которые помогут вам в вашем путешествии. С GoFr вы сможете сосредоточиться на создании надежных, масштабируемых и эффективно управляемых микросервисов, что позволит вам уделять больше времени основным функциям вашего приложения.
Начните работу с GoFr уже сегодня!
