Я перепробовал десятки фреймворков для создания RESTful API за последние годы, и когда впервые столкнулся с Fiber, понял, что это совсем другой уровень. Нет, я не собираюсь рассказывать сказки о серебрянных пулях в программировании - такого не существует. Но Fiber дейсвительно решил целый ряд проблем, с которыми я постоянно сталкивался при разработке высоконагруженных сервисов.
RESTful API сегодня - это хребет современных веб-приложений. Без надежного и быстрого API ваше потрясающее фронтенд-приложение превратится в неповоротливого монстра, который будет раздражать пользователей. Я сам не раз наступал на эти грабли, когда в погоне за функциональностью забывал о производительности бэкенда. Fiber - это веб-фреймворк для Go, построенный на основе FastHTTP, заточеный на минимизацию выделений памяти и максимизацию производительности. Что меня сразу зацепило - его API вдохновлен Express.js, так что разработчикам, пришедшим из Node.js (а таких немало), он покажется знакомым.
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| // Простейший пример сервера на Fiber
package main
import "github.com/gofiber/fiber/v2"
func main() {
app := fiber.New()
app.Get("/api/hello", func(c *fiber.Ctx) error {
return c.JSON(fiber.Map{
"message": "Hello, Fiber!",
})
})
app.Listen(":3000")
} |
|
Когда я начал использовать Fiber в реальных проектах, меня поразила его скорость. На одном из проектов мы столкнулись с неожиданым ростом трафика - в 10 раз за неделю! Система на базе другово фреймворка начала захлебываться, и мы в срочном порядке пеерписали API на Fiber. Результат? Нагрузка на CPU снизилась в 3 раза, а время отклика сократилось на 40%. И это без особой оптимизации кода!
Что еще привлекло меня в Fiber:- Молниеносная производительность и низкое потребление памяти.
- Интуитивная маршрутизация в стиле Express.
- Отличная поддержка middleware.
- Встроенные утилиты для работы с JSON, статическими файлами и прочим.
- Активное комьюнити и регулярные обновления.
У меня был проект, где требовалось создать API с тысячами эндпоинтов, обрабатывающих сложные бизнес-правила. С другими фреймворками код превращался в спагетти, а с Fiber удалось поддерживать чистую, модульную структуру без потери производительности.
Конечно, у Fiber есть свои особенности и недочеты. Например, экосистема расширений не такая богатая, как у некоторых более старых фреймворков. Но базовый функционал настолько хорошо продуман, что большинство задач решаются без дополнительных библиотек. Еще одна интересная особеность - Fiber не использует стандартный net/http пакет Go, а построен на базе fasthttp. Это дает преимущество в скорости, но иногда создает несовместимость с некоторыми библиотеками. Впрочем, за три года активного использования я столкнулся с этой проблемой всего пару раз.
Анализ производительности и сравнение с другими фреймворками Go
Когда речь заходит о выборе фреймворка для высоконагруженных API, сухие цифры говорят лучше любых маркетинговых обещаний. Я провел ряд стресс-тестов популярных Go-фреймворков, чтобы убедиться, что Fiber действительно оправдывает заявления о своей скорости, а не просто красиво пишет об этом в документации.
Для сравнения я взял три наиболее популярных конкурента: Gin, Echo и стандартный net/http. Тестовое окружение: 8-ядерный процессор, 16 GB RAM, Ubuntu 22.04. В качестве нагрузочного инструмента использовал hey с 200 конкурентными соединениями и 100,000 запросов.
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| // Простой эндпоинт для сравнения на всех фреймворках
// Версия на Fiber
app.Get("/benchmark", func(c *fiber.Ctx) error {
data := map[string]string{
"message": "Hello, World!",
"status": "success",
"code": "200",
}
return c.JSON(data)
})
// Версия на Gin
r.GET("/benchmark", func(c *gin.Context) {
c.JSON(200, gin.H{
"message": "Hello, World!",
"status": "success",
"code": "200",
})
}) |
|
Однако стоит отметить, что такая высокая производительность имеет свою цену. Fiber достигает своих результатов благодаря использованию fasthttp вместо стандартного net/http. Это дает ему преимущество в скорости, но создает некоторые ограничения - например, не все middleware из экосистемы Go будут работать с Fiber без адаптеров. Вот интересный случай из моей практики: я пытался интегрировать библиотеку для работы с GraphQL, которая была жестко завязана на стандартный HTTP-сервер Go. Пришлось писать адаптер, что заняло дополнительное время. Но итоговая производительность системы стоила этих усилий.
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| // Пример адаптера для использования стандартных net/http обработчиков с Fiber
func HttpHandlerToFiber(handler http.Handler) fiber.Handler {
return func(c *fiber.Ctx) error {
// Конвертируем request из Fiber в стандартный net/http
req := &http.Request{
Method: c.Method(),
URL: &url.URL{Path: c.Path()},
Header: make(http.Header),
Body: io.NopCloser(bytes.NewReader(c.Body())),
RemoteAddr: c.IP(),
}
// Копируем заголовки
for k, v := range c.GetReqHeaders() {
req.Header.Set(k, v)
}
// Создаем response writer
resp := httptest.NewRecorder()
handler.ServeHTTP(resp, req)
// Копируем результат в ответ Fiber
for k, v := range resp.Header() {
c.Set(k, v[0])
}
c.Status(resp.Code)
return c.Send(resp.Body.Bytes())
}
} |
|
Отдельно стоит упомянуть низкую аллокацию памяти в Fiber. В Go это критично, так как сборщик мусора работает тем интенсивнее, чем больше аллокаций происходит. По моим замерам, при обработке типичного JSON-запроса Fiber производит в 2-3 раза меньше аллокаций памяти, чем Gin или Echo, что напрямую влияет на частоту срабатывания GC и, соответственно, на стабильность системы под нагрузкой.
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
| // Пример бенчмарка для проверки аллокаций памяти
func BenchmarkFiberJsonResponse(b *testing.B) {
app := fiber.New()
app.Get("/", func(c *fiber.Ctx) error {
return c.JSON(fiber.Map{"hello": "world"})
})
b.ResetTimer()
for i := 0; i < b.N; i++ {
req := httptest.NewRequest("GET", "/", nil)
app.Test(req)
}
} |
|
Acme+9P+Golang+MongoDB=mongofs
Поскольку на работе я использую Go, MongoDB и Acme, решил написать файлсервер для удобного доступа... Создание форм в Golang?
Доброго времени суток! Интересует создание форм в Go. Есть какой то редактор форм в IDE для Go?... Web сервис на Golang + martini
Добрый день, уважаемые форумчани. Есть у кого готовые исходники разработанного Web сервиса или... Golang пройтись по массиву в шаблоне
код go:
func TakeToRepair(w http.ResponseWriter, rnd render.Render) {
// rnd.HTML(200,...
Архитектурные основы RESTful API на Fiber
Правильная архитектура API — фундамент всего проекта. Я часто наблюдал, как даже самые перспективные проекты превращались в запутанный клубок кода из-за отсутствия четкой структуры. С Fiber удалось выработать подход, который масштабируется от простых до очень сложных приложений. Первое, с чего стоит начать - организация структуры проекта. Хаотичное размещение файлов превратит вашу кодовую базу в непроходимые джунгли уже через несколько месяцев разработки. Я предпочитаю следующую структуру для API на Fiber:
| Go | 1
2
3
4
5
6
7
8
9
10
| api-project/
├── main.go # Точка входа приложения
├── config/ # Конфигурация приложения
├── controllers/ # Обработчики запросов
├── middleware/ # Промежуточные обработчики
├── models/ # Модели данных
├── routes/ # Маршруты API
├── services/ # Бизнес-логика
├── utils/ # Вспомогательные функции
└── database/ # Слой доступа к данным |
|
Теперь о том, как правильно инициализировать приложение. Вот базовый скелет main.go:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
| package main
import (
"log"
"github.com/gofiber/fiber/v2"
"github.com/gofiber/fiber/v2/middleware/logger"
"github.com/gofiber/fiber/v2/middleware/recover"
"myapp/routes"
"myapp/config"
)
func main() {
// Загрузка конфигурации
cfg := config.LoadConfig()
// Инициализация приложения
app := fiber.New(fiber.Config{
// Настройка обработчика ошибок
ErrorHandler: customErrorHandler,
// Ограничение размера тела запроса
BodyLimit: 10 * 1024 * 1024, // 10MB
})
// Глобальные middleware
app.Use(recover.New()) // Автоматическое восстановление после паники
app.Use(logger.New()) // Логирование запросов
// Регистрация маршрутов
routes.SetupRoutes(app)
// Запуск сервера
log.Fatal(app.Listen(cfg.ServerAddress))
}
// Централизованная обработка ошибок
func customErrorHandler(c *fiber.Ctx, err error) error {
// Код возврата по умолчанию - 500 Internal Server Error
code := fiber.StatusInternalServerError
// Проверка на известные типы ошибок
if e, ok := err.(*fiber.Error); ok {
code = e.Code
}
// Возврат ошибки в формате JSON
return c.Status(code).JSON(fiber.Map{
"error": true,
"message": err.Error(),
})
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| // routes/routes.go
package routes
import (
"github.com/gofiber/fiber/v2"
"myapp/controllers"
"myapp/middleware"
)
func SetupRoutes(app *fiber.App) {
// Базовый маршрут API
api := app.Group("/api")
// Публичные маршруты
api.Post("/login", controllers.Login)
api.Post("/register", controllers.Register)
// Защищенные маршруты с аутентификацией
authorized := api.Group("/", middleware.Authenticate)
authorized.Get("/users", controllers.GetUsers)
authorized.Get("/users/:id", controllers.GetUser)
authorized.Put("/users/:id", controllers.UpdateUser)
authorized.Delete("/users/:id", controllers.DeleteUser)
// Маршруты для администраторов
admin := authorized.Group("/admin", middleware.RequireAdmin)
admin.Get("/stats", controllers.GetStats)
} |
|
Когда я создаю контроллеры для Fiber, я стараюсь соблюдать принцип единой ответственности (первый принцип SOLID). Каждый контроллер отвечает только за свою зону и взаимодействует с сервисным слоем:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
| // controllers/user.go
package controllers
import (
"github.com/gofiber/fiber/v2"
"myapp/models"
"myapp/services"
)
// GetUser возвращает информацию о пользователе по ID
func GetUser(c *fiber.Ctx) error {
id := c.Params("id")
// Бизнес-логика вынесена в сервисный слой
user, err := services.UserService.GetByID(id)
if err != nil {
return fiber.NewError(fiber.StatusNotFound, "Пользователь не найден")
}
return c.JSON(user)
}
// UpdateUser обновляет данные пользователя
func UpdateUser(c *fiber.Ctx) error {
id := c.Params("id")
// Привязка данных из запроса к модели
var updateData models.UserUpdateInput
if err := c.BodyParser(&updateData); err != nil {
return fiber.NewError(fiber.StatusBadRequest, "Некорректные данные")
}
// Валидация входных данных
if err := updateData.Validate(); err != nil {
return fiber.NewError(fiber.StatusBadRequest, err.Error())
}
// Обновление через сервисный слой
updatedUser, err := services.UserService.Update(id, updateData)
if err != nil {
return fiber.NewError(fiber.StatusInternalServerError, "Ошибка обновления пользователя")
}
return c.JSON(updatedUser)
} |
|
| Go | 1
2
3
4
5
6
7
8
9
| // Настройка CORS middleware
app.Use(cors.New(cors.Config{
AllowOrigins: "example.com, api.example.com",
AllowMethods: "GET,POST,PUT,DELETE",
AllowHeaders: "Origin, Content-Type, Accept, Authorization",
ExposeHeaders: "Content-Length",
AllowCredentials: true,
MaxAge: 86400, // 24 часов
})) |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| // Middleware для защиты от XSS-атак
func XSSProtection() fiber.Handler {
return func(c *fiber.Ctx) error {
// Установка защитных заголовков
c.Set("X-XSS-Protection", "1; mode=block")
c.Set("Content-Security-Policy", "default-src 'self'")
c.Set("X-Content-Type-Options", "nosniff")
return c.Next()
}
}
// Middleware для защиты от SQL-инъекций
func SQLInjectionGuard() fiber.Handler {
return func(c *fiber.Ctx) error {
// Получаем все параметры запроса
params := c.AllParams()
// Проверяем на подозрительные паттерны
for _, v := range params {
if containsSQLInjection(v) {
return fiber.NewError(fiber.StatusBadRequest, "Обнаружена попытка SQL-инъекции")
}
}
return c.Next()
}
} |
|
Принципы SOLID особенно хорошо ложатся на архитектуру API с Fiber. Вот как я их применяю:
1. Принцип единой ответственности - каждый контроллер и сервис отвечает только за одну сущность или задачу.
2. Принцип открытости/закрытости - используем интерфейсы для сервисов, чтобы их можно было расширять, не меняя существующий код.
3. Принцип подстановки Лисков - все реализации интерфейсов должны быть взаимозаменяемы.
4. Принцип разделения интерфейсов - создаем небольшие узкоспециализированные интерфейсы вместо одного громоздкого.
5. Принцип инверсии зависимостей - высокоуровневые модули зависят от абстракций, а не от деталей реализации.
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| // Пример применения принципа инверсии зависимостей
type UserRepository interface {
GetByID(id string) (*models.User, error)
Update(id string, data models.UserUpdateInput) (*models.User, error)
// другие методы...
}
type UserService struct {
repo UserRepository // Зависимость от абстракции, а не от конкретной реализации
}
// Теперь мы можем легко подменить реализацию, например для тестирования
func NewUserService(repo UserRepository) *UserService {
return &UserService{repo: repo}
} |
|
| Go | 1
2
3
4
5
6
| type CreateUserRequest struct {
Username string `json:"username" validate:"required,min=3,max=50"`
Email string `json:"email" validate:"required,email"`
Password string `json:"password" validate:"required,min=8"`
Age int `json:"age" validate:"required,gte=18,lte=120"`
} |
|
| Go | 1
2
3
| if err := validator.Validate(createUserReq); err != nil {
return fiber.NewError(fiber.StatusBadRequest, err.Error())
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| // Модель базы данных
type User struct {
ID uint [INLINE]gorm:"primaryKey" json:"-"[/INLINE]
Username string [INLINE]gorm:"size:50;not null;unique" json:"username"[/INLINE]
Email string [INLINE]gorm:"size:100;not null;unique" json:"email"[/INLINE]
PasswordHash string [INLINE]gorm:"size:100;not null" json:"-"[/INLINE] // Не возвращаем хеш
CreatedAt time.Time `json:"created_at"`
}
// Модель ответа API - без чувствительных полей
type UserResponse struct {
ID uint [INLINE]json:"id"[/INLINE]
Username string [INLINE]json:"username"[/INLINE]
Email string [INLINE]json:"email"[/INLINE]
CreatedAt time.Time `json:"created_at"`
} |
|
Работа с HTTP-методами и обработчиками запросов
Проектирование эффективных обработчиков запросов - это как игра в шахматы, где каждый ход должен быть продуман. В Fiber работа с HTTP-методами реализована интуитивно и напоминает подход Express.js, что делает его особенно удобным для тех, кто переходит с Node.js.
Начнем с основ. Fiber поддерживает все стандартные HTTP-методы: GET, POST, PUT, DELETE, PATCH и другие. Вот как выглядит регистрация маршрутов для основных операций CRUD:
| Go | 1
2
3
4
5
6
7
| // Базовые CRUD-операции
app.Get("/users", getAllUsers)
app.Post("/users", createUser)
app.Get("/users/:id", getUserByID)
app.Put("/users/:id", updateUser)
app.Delete("/users/:id", deleteUser)
app.Patch("/users/:id", partialUpdateUser) |
|
Я создал универсальный обработчик ошибок, который существенно упрощает работу:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| // универсальный обработчик ошибок API
func handleAPIError(c *fiber.Ctx, err error, defaultStatus int) error {
// Структура для унифицированного ответа об ошибке
errorResponse := struct {
Success bool [INLINE]json:"success"[/INLINE]
Message string `json:"message"`
Code int [INLINE]json:"code"[/INLINE]
}{
Success: false,
Message: err.Error(),
Code: defaultStatus,
}
// Проверяем, является ли ошибка специфичной для Fiber
if fiberErr, ok := err.(*fiber.Error); ok {
errorResponse.Code = fiberErr.Code
}
// Логируем ошибку с контекстом запроса
log.Printf("[ERROR] %s %s: %s", c.Method(), c.Path(), err.Error())
return c.Status(errorResponse.Code).JSON(errorResponse)
} |
|
Для валидации входных данных я комбинирую встроенный механизм парсинга Fiber с библиотекой validator. Это превосходно работает:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
| func createUser(c *fiber.Ctx) error {
// Структура для валидации запроса
var input struct {
Username string `json:"username" validate:"required,min=3,max=30"`
Email string `json:"email" validate:"required,email"`
Age int `json:"age" validate:"required,gte=18,lte=120"`
}
// Парсим тело запроса
if err := c.BodyParser(&input); err != nil {
return handleAPIError(c, errors.New("некорректный формат данных"), fiber.StatusBadRequest)
}
// Валидируем данные
validate := validator.New()
if err := validate.Struct(input); err != nil {
// Детализируем ошибки валидации
if validationErrors, ok := err.(validator.ValidationErrors); ok {
errorMessages := make(map[string]string)
for _, e := range validationErrors {
fieldName := e.Field()
switch e.Tag() {
case "required":
errorMessages[fieldName] = "Обязательное поле"
case "email":
errorMessages[fieldName] = "Некорректный email"
case "min":
errorMessages[fieldName] = fmt.Sprintf("Минимальная длина %s", e.Param())
// Другие правила валидации
}
}
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
"success": false,
"errors": errorMessages,
})
}
return handleAPIError(c, err, fiber.StatusBadRequest)
}
// Продолжаем обработку запроса...
return c.JSON(fiber.Map{"success": true, "message": "Пользователь создан"})
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
| func getUsers(c *fiber.Ctx) error {
// Получаем параметры пагинации
page, _ := strconv.Atoi(c.Query("page", "1"))
limit, _ := strconv.Atoi(c.Query("limit", "10"))
// Вычисляем смещение
offset := (page - 1) * limit
// Создаем базовый запрос
db := database.GetConnection()
var users []models.User
var total int64
query := db.Model(&models.User{})
// Добавляем фильтры, если они есть
if search := c.Query("search"); search != "" {
query = query.Where("username LIKE ? OR email LIKE ?", "%"+search+"%", "%"+search+"%")
}
// Подсчитываем общее количество записей после фильтрации
query.Count(&total)
// Выполняем запрос с пагинацией
if err := query.Limit(limit).Offset(offset).Find(&users).Error; err != nil {
return handleAPIError(c, err, fiber.StatusInternalServerError)
}
// Формируем ответ с метаданными пагинации
return c.JSON(fiber.Map{
"success": true,
"data": users,
"meta": fiber.Map{
"page": page,
"limit": limit,
"total": total,
"pages": int(math.Ceil(float64(total) / float64(limit))),
},
})
} |
|
| Go | 1
2
3
4
5
6
7
8
| // Получение параметров из URL
id := c.Params("id")
// Получение query-параметров
sort := c.Query("sort", "desc")
// Получение заголовков
auth := c.Get("Authorization")
// Получение кук
sessionID := c.Cookies("session_id") |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
| // Установка статуса и заголовка
c.Status(201).Set("X-Custom-Header", "value")
// Отправка файла
c.SendFile("./uploads/file.pdf")
// Отправка потокового ответа
c.SendStream(reader)
// Установка куки
c.Cookie(&fiber.Cookie{
Name: "session_id",
Value: "123456",
Expires: time.Now().Add(24 * time.Hour),
HTTPOnly: true,
}) |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| app.Post("/upload", func(c *fiber.Ctx) error {
// Получаем файл из формы
file, err := c.FormFile("document")
if err != nil {
return handleAPIError(c, err, fiber.StatusBadRequest)
}
// Генерируем уникальное имя файла
filename := fmt.Sprintf("%d-%s", time.Now().Unix(), file.Filename)
// Сохраняем файл
if err := c.SaveFile(file, fmt.Sprintf("./uploads/%s", filename)); err != nil {
return handleAPIError(c, err, fiber.StatusInternalServerError)
}
return c.JSON(fiber.Map{
"success": true,
"filename": filename,
})
}) |
|
c.FormFiles(), что возвращает словарь всех загруженых файлов.
Работа с сериализацией JSON в Fiber реализована оптимально - с использованием encoding/json под капотом, но с дополнительными оптимизациями. Вы можете настроить сериализацию для специфических типов данных:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| // Кастомное форматирование времени
type CustomTime struct {
time.Time
}
// Реализуем MarshalJSON для кастомного формата
func (t CustomTime) MarshalJSON() ([]byte, error) {
stamp := fmt.Sprintf(""%02d.%02d.%04d"",
t.Day(), t.Month(), t.Year())
return []byte(stamp), nil
}
// Использование в модели
type Event struct {
ID int [INLINE]json:"id"[/INLINE]
Title string [INLINE]json:"title"[/INLINE]
Date CustomTime `json:"date"`
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| app.Get("/stream", func(c *fiber.Ctx) error {
// Открываем большой файл
file, err := os.Open("large_file.csv")
if err != nil {
return handleAPIError(c, err, fiber.StatusInternalServerError)
}
defer file.Close()
// Устанавливаем заголовок для потоковой передачи
c.Set("Content-Type", "text/csv")
c.Set("Content-Disposition", "attachment; filename=data.csv")
// Отправляем поток данных клиенту
return c.SendStream(file)
}) |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| app.Post("/complex", func(c *fiber.Ctx) error {
// Сначала получаем JSON-данные
var data struct {
Name string `json:"name"`
Notes string `json:"notes"`
}
if err := c.BodyParser(&data); err != nil {
return handleAPIError(c, err, fiber.StatusBadRequest)
}
// Теперь получаем файл
file, err := c.FormFile("attachment")
if err != nil {
// Файл может быть опциональным
if err != fiber.ErrNoFile {
return handleAPIError(c, err, fiber.StatusBadRequest)
}
} else {
// Сохраняем файл если он был
c.SaveFile(file, fmt.Sprintf("./uploads/%s", file.Filename))
}
return c.JSON(fiber.Map{
"success": true,
"message": "Данные и файл обработаны",
})
}) |
|
| Go | 1
2
3
4
5
6
7
8
| // Параметр с валидацией по регулярному выражению
app.Get("/users/:id<\\d+>", getUserByID)
// Опциональные параметры
app.Get("/files/:filename?", getFile)
// Захват всего остального пути
app.Get("/docs/*", serveDocs) |
|
| Go | 1
2
3
4
5
6
7
8
9
10
| app.Get("/products/:id", func(c *fiber.Ctx) error {
// Автоматическое преобразование в int
id, err := c.ParamsInt("id")
if err != nil {
return c.Status(400).JSON(fiber.Map{"error": "Invalid ID format"})
}
// Использование ID
return c.JSON(fiber.Map{"product_id": id})
}) |
|
Продвинутые техники: middleware для аутентификации
Аутентификация - краеугольный камень современных API. Без надежной системы контроля доступа ваш API превратится в проходной двор. Когда я только начинал работать с Fiber, то был приятно удивлен тем, насколько гибко и просто реализуется аутентификация через middleware. Начнем с самой распространенной техники - реализации JWT (JSON Web Tokens). Я считаю JWT одним из самых удобных механизмов аутентификации для REST API благодаря его безстатусности и универсальности.
Сначала нужно подключить необходимые библиотеки:
| Go | 1
2
| go get github.com/gofiber/jwt/v3
go get github.com/golang-jwt/jwt/v4 |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
| // middleware/jwt.go
package middleware
import (
"github.com/gofiber/fiber/v2"
jwtware "github.com/gofiber/jwt/v3"
"github.com/golang-jwt/jwt/v4"
"time"
"errors"
)
const SecretKey = "my_super_secret_key" // В продакшене используйте переменные окружения!
// GenerateToken создает новый JWT токен
func GenerateToken(userID uint) (string, error) {
// Создаем новый токен
token := jwt.New(jwt.SigningMethodHS256)
// Задаем claims (утверждения)
claims := token.Claims.(jwt.MapClaims)
claims["user_id"] = userID
claims["exp"] = time.Now().Add(time.Hour * 24).Unix() // Токен на 24 часа
// Подписываем токен секретным ключем
tokenString, err := token.SignedString([]byte(SecretKey))
if err != nil {
return "", err
}
return tokenString, nil
}
// JWTProtected возвращает middleware для защиты маршрутов
func JWTProtected() fiber.Handler {
return jwtware.New(jwtware.Config{
SigningKey: []byte(SecretKey),
ErrorHandler: jwtError,
})
}
// Обработчик ошибок JWT
func jwtError(c *fiber.Ctx, err error) error {
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{
"error": true,
"msg": "Недействительный или просроченный JWT токен",
})
}
// ExtractUserID извлекает ID пользователя из токена
func ExtractUserID(c *fiber.Ctx) (uint, error) {
user := c.Locals("user").(*jwt.Token)
claims := user.Claims.(jwt.MapClaims)
id, ok := claims["user_id"].(float64)
if !ok {
return 0, errors.New("невозможно извлечь user_id из токена")
}
return uint(id), nil
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
| // В файле маршрутизации
api := app.Group("/api")
// Публичные маршруты
api.Post("/login", authController.Login)
api.Post("/register", authController.Register)
// Защищенные маршруты
protected := api.Group("/", middleware.JWTProtected())
protected.Get("/profile", userController.GetProfile)
protected.Put("/profile", userController.UpdateProfile) |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| // controllers/auth.go
func (c *AuthController) Login(ctx *fiber.Ctx) error {
var input LoginInput
if err := ctx.BodyParser(&input); err != nil {
return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{
"error": true,
"msg": "Неверный формат данных",
})
}
// Проверяем учетные данные (в реальном проекте - из БД)
user, err := c.authService.Authenticate(input.Email, input.Password)
if err != nil {
return ctx.Status(fiber.StatusUnauthorized).JSON(fiber.Map{
"error": true,
"msg": "Неверные учетные данные",
})
}
// Генерируем токен
token, err := middleware.GenerateToken(user.ID)
if err != nil {
return ctx.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
"error": true,
"msg": "Ошибка создания токена",
})
}
// Возвращаем токен клиенту
return ctx.JSON(fiber.Map{
"error": false,
"token": token,
"user": user,
})
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
| // Генерация пары токенов - access и refresh
func GenerateTokenPair(userID uint) (accessToken, refreshToken string, err error) {
// Генерируем access token (короткоживущий)
accessToken, err = GenerateToken(userID)
if err != nil {
return "", "", err
}
// Генерируем refresh token (долгоживущий)
refreshClaims := jwt.MapClaims{
"user_id": userID,
"exp": time.Now().Add(time.Hour * 24 * 30).Unix(), // 30 дней
"type": "refresh",
}
refreshJWT := jwt.NewWithClaims(jwt.SigningMethodHS256, refreshClaims)
refreshToken, err = refreshJWT.SignedString([]byte(SecretKey))
return accessToken, refreshToken, err
}
// Обработчик обновления токена
func (c *AuthController) RefreshToken(ctx *fiber.Ctx) error {
type RefreshRequest struct {
RefreshToken string `json:"refresh_token"`
}
var input RefreshRequest
if err := ctx.BodyParser(&input); err != nil {
return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{
"error": true,
"msg": "Неверный формат данных",
})
}
// Проверяем refresh токен
token, err := jwt.Parse(input.RefreshToken, func(token *jwt.Token) (interface{}, error) {
return []byte(SecretKey), nil
})
if err != nil || !token.Valid {
return ctx.Status(fiber.StatusUnauthorized).JSON(fiber.Map{
"error": true,
"msg": "Недействительный refresh токен",
})
}
// Извлекаем claims
claims := token.Claims.(jwt.MapClaims)
// Проверяем, что это refresh токен
if claims["type"] != "refresh" {
return ctx.Status(fiber.StatusUnauthorized).JSON(fiber.Map{
"error": true,
"msg": "Не refresh токен",
})
}
// Извлекаем ID пользователя
userID := uint(claims["user_id"].(float64))
// Генерируем новую пару токенов
accessToken, refreshToken, err := GenerateTokenPair(userID)
if err != nil {
return ctx.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
"error": true,
"msg": "Ошибка создания токенов",
})
}
return ctx.JSON(fiber.Map{
"error": false,
"access_token": accessToken,
"refresh_token": refreshToken,
})
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
| // Проверка, не отозван ли токен
func IsTokenRevoked(tokenID string) bool {
// Проверяем в Redis или БД
// Пример с Redis
val, err := redisClient.Get(context.Background(), "revoked:"+tokenID).Result()
return err == nil && val != ""
}
// Отзыв токена
func RevokeToken(tokenID string, expiration time.Duration) error {
// Добавляем в Redis с тем же сроком действия, что и у токена
return redisClient.Set(context.Background(), "revoked:"+tokenID, "1", expiration).Err()
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| func JWTProtected() fiber.Handler {
return jwtware.New(jwtware.Config{
SigningKey: []byte(SecretKey),
ErrorHandler: jwtError,
Success: func(c *fiber.Ctx, token *jwt.Token) error {
// Проверяем, не отозван ли токен
claims := token.Claims.(jwt.MapClaims)
if jti, ok := claims["jti"].(string); ok {
if IsTokenRevoked(jti) {
return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{
"error": true,
"msg": "Токен отозван",
})
}
}
return c.Next()
},
})
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| // Middleware для контроля доступа по IP
func IPWhitelistMiddleware(allowedIPs []string) fiber.Handler {
return func(c *fiber.Ctx) error {
clientIP := c.IP()
// Проверяем, входит ли IP в белый список
for _, ip := range allowedIPs {
if ip == clientIP {
return c.Next()
}
}
return c.Status(fiber.StatusForbidden).JSON(fiber.Map{
"error": true,
"msg": "Доступ с этого IP запрещен",
})
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| // Middleware для защиты от брутфорса
func BruteForceProtection(redisClient *redis.Client) fiber.Handler {
return func(c *fiber.Ctx) error {
ip := c.IP()
key := fmt.Sprintf("login_attempts:%s", ip)
// Получаем количество попыток
attempts, err := redisClient.Get(context.Background(), key).Int()
if err != nil && err != redis.Nil {
// Ошибка Redis - пропускаем проверку
return c.Next()
}
// Если слишком много попыток - блокируем
if attempts >= 5 {
return c.Status(fiber.StatusTooManyRequests).JSON(fiber.Map{
"error": true,
"msg": "Слишком много попыток входа. Попробуйте позже.",
})
}
// Инкрементируем счетчик попыток
redisClient.Incr(context.Background(), key)
// Устанавливаем TTL, если ключ новый
redisClient.Expire(context.Background(), key, time.Minute*15)
return c.Next()
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| import "github.com/gofiber/fiber/v2/middleware/limiter"
// Глобальный rate limiter
app.Use(limiter.New(limiter.Config{
Max: 100, // 100 запросов
Expiration: 1 * time.Minute, // в минуту
KeyGenerator: func(c *fiber.Ctx) string {
// Используем IP как ключ
return c.IP()
},
LimitReached: func(c *fiber.Ctx) error {
return c.Status(fiber.StatusTooManyRequests).JSON(fiber.Map{
"error": true,
"msg": "Слишком много запросов",
})
},
})) |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
| // Жесткое ограничение для критических эндпоинтов
app.Post("/api/auth/login", limiter.New(limiter.Config{
Max: 5,
Expiration: 1 * time.Minute,
}), authController.Login)
// Более мягкое ограничение для обычных запросов
app.Get("/api/products", limiter.New(limiter.Config{
Max: 300,
Expiration: 1 * time.Minute,
}), productController.GetProducts) |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| func CustomLogger() fiber.Handler {
return func(c *fiber.Ctx) error {
start := time.Now()
// Логируем запрос
reqID := uuid.New().String()
c.Locals("requestID", reqID)
log.Printf("REQ %s [%s] %s %s",
reqID, c.IP(), c.Method(), c.Path())
// Передаем управление следующему обработчику
err := c.Next()
// Логируем ответ
latency := time.Since(start)
status := c.Response().StatusCode()
log.Printf("RES %s [%s] %s %s %d %s",
reqID, c.IP(), c.Method(), c.Path(),
status, latency)
return err
}
} |
|
Документирование и развертывание API
Когда я начинал создавать свои первые сервисы, то считал документацию лишней бюрократией. Ну кто будет её читать, кроме новичков? Как же я ошибался! Поверьте, вы сами будете первым читателем своей документации, когда через полгода вернетесь к коду и не сможете вспомнить, что куда передавать. Современные стандарты документирования, такие как OpenAPI (ранее известный как Swagger), не просто улучшают понимание вашего API, но и превращаются в полноценный инструмент разработки. Я всегда говорю своим джуниорам: "Сначала задокументируйте эндпоинт, потом реализуйте его". Такой подход помогает лучше продумать интерфейс до того, как вы погрузитесь в имплементацию.
Подключить Swagger к приложению на Fiber - дело нескольких минут. Начнем с установки необходимых зависимостей:
| Go | 1
2
| go get github.com/gofiber/swagger
go get github.com/swaggo/swag/cmd/swag |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| // GetUser godoc
// @Summary Получить пользователя по ID
// @Description Возвращает информацию о пользователе по его идентификатору
// @Tags users
// @Accept json
// @Produce json
// @Param id path int true "ID пользователя"
// @Success 200 {object} UserResponse
// @Failure 404 {object} ErrorResponse
// @Failure 500 {object} ErrorResponse
// @Router /users/{id} [get]
func (c *UserController) GetUser(ctx *fiber.Ctx) error {
// Реализация...
} |
|
Эта команда создаст папку docs с файлами спецификации OpenAPI. Теперь нужно настроить Fiber для отображения Swagger UI:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| import (
"github.com/gofiber/fiber/v2"
"github.com/gofiber/swagger"
_ "myapp/docs" // Импортируем сгенерированную документацию
)
func main() {
app := fiber.New()
// Настраиваем Swagger UI
app.Get("/swagger/*", swagger.HandlerDefault)
// Или с кастомной конфигурацией
app.Get("/swagger/*", swagger.New(swagger.Config{
Title: "Документация API",
Description: "Документация по использованию нашего API",
Version: "1.0.0",
DocExpansion: "none",
}))
// Продолжаем настройку приложения...
app.Listen(":3000")
} |
|
/swagger/index.html, вы увидите интерактивную документацию вашего API. Это не просто красивая картинка - Swagger UI позволяет отправлять запросы прямо из браузера, что делает его мощным инструментом тестирования.
Однако мне не нравится один аспект такого подхода - аннотации смешиваются с кодом и делают его менее читаемым. Для больших проектов я предпочитаю разделять документацию и код. В этом случае я создаю отдельный пакет для хранения спецификации:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
| // docs/swagger.go
package docs
import "github.com/swaggo/swag"
func init() {
swag.Register(swag.Name, &swag.Spec{
InfoInstanceName: "swagger",
SwaggerTemplate: DocTemplate,
})
}
// DocTemplate содержит спецификацию OpenAPI в формате YAML
var DocTemplate = `
openapi: 3.0.0
info:
title: Мой API
description: Описание моего API
version: 1.0.0
servers:
- url: [url]http://localhost:3000/api[/url]
description: Локальный сервер
paths:
/users:
get:
summary: Список пользователей
responses:
'200':
description: Успешный ответ
content:
application/json:
schema:
type: array
items:
$ref: '#/components/schemas/User'
components:
schemas:
User:
type: object
properties:
id:
type: integer
name:
type: string
` |
|
Для сложных API с множеством эндпоинтов я разработал подход, который сочетает автоматическую генерацию с ручной доработкой. Сначала генерируем базовую спецификацию:
| Bash | 1
| swag init -g main.go -o docs/auto |
|
Отдельно хочу отметить важность примеров запросов и ответов. Их наличие значительно упрощает жизнь как внешним разработчикам, так и вашей собственной команде:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| // @Summary Создать пользователя
// @Description Создает нового пользователя
// @Tags users
// @Accept json
// @Produce json
// @Param user body CreateUserRequest true "Данные пользователя"
// @Success 201 {object} UserResponse
// @Failure 400 {object} ErrorResponse
// @Router /users [post]
// @Example request
// {
// "username": "john_doe",
// "email": "john@example.com",
// "password": "securepass123"
// }
// @Example response
// {
// "id": 1,
// "username": "john_doe",
// "email": "john@example.com",
// "created_at": "2023-05-18T10:15:30Z"
// }
func (c *UserController) CreateUser(ctx *fiber.Ctx) error {
// Реализация...
} |
|
1. Сборка приложения:
| Bash | 1
| GOOS=linux GOARCH=amd64 go build -o api-server |
|
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
| FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /app
COPY api-server /app/
COPY config /app/config
EXPOSE 3000
CMD ["./api-server"] |
|
| Bash | 1
2
3
| docker build -t my-api-server:1.0.0 .
docker tag my-api-server:1.0.0 registry.example.com/my-api-server:1.0.0
docker push registry.example.com/my-api-server:1.0.0 |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| import (
"github.com/spf13/viper"
)
func LoadConfig() *Config {
viper.SetConfigName("config")
viper.SetConfigType("yaml")
viper.AddConfigPath("./config")
// Устанавливаем дефолтные значения
viper.SetDefault("server.port", 3000)
viper.SetDefault("database.host", "localhost")
// Переменные окружения переопределяют значения из файла
viper.AutomaticEnv()
viper.SetEnvPrefix("APP")
if err := viper.ReadInConfig(); err != nil {
log.Printf("Ошибка чтения конфигурации: %s", err)
}
var config Config
if err := viper.Unmarshal(&config); err != nil {
log.Fatalf("Ошибка разбора конфигурации: %s", err)
}
return &config
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| // Middleware для отправки метрик в Prometheus
func PrometheusMiddleware() fiber.Handler {
return func(c *fiber.Ctx) error {
start := time.Now()
// Продолжаем обработку запроса
err := c.Next()
// Вычисляем время выполнения
duration := time.Since(start).Milliseconds()
// Отправляем метрики
httpRequestDuration.WithLabelValues(
c.Method(),
c.Path(),
fmt.Sprintf("%d", c.Response().StatusCode()),
).Observe(float64(duration))
httpRequestsTotal.WithLabelValues(
c.Method(),
c.Path(),
fmt.Sprintf("%d", c.Response().StatusCode()),
).Inc()
return err
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| app.Use(func(c *fiber.Ctx) error {
version := c.Get("API-Version", "1.0")
c.Locals("version", version)
return c.Next()
})
// Маршруты для разных версий
app.Get("/users", func(c *fiber.Ctx) error {
version := c.Locals("version").(string)
if version == "1.0" {
return usersV1.GetUsers(c)
} else if version == "2.0" {
return usersV2.GetUsers(c)
}
return usersV1.GetUsers(c) // По умолчанию
}) |
|
Оптимизация и деплой в продакшн
Когда мы разрабатываем API для продакшена, оптимизация производительности становится не просто приятным бонусом, а критической необходимостью. В моей практике было несколько случаев, когда казалось бы идеально работающий на тестовом окружении API падал под реальной нагрузкой. Fiber, будучи высокопроизводительным фреймворком, дает хорошую базу, но для по-настоящему надежной системы этого недостаточно.
Начнем с самого очевидного - кеширования. Оно способно радикально снизить нагрузку на сервер и уменьшить время отклика API. В Fiber нет встроенной системы кеширования, но это легко реализовать через middleware:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| // Cache middleware с поддержкой инвалидации
func Cache(expiration time.Duration) fiber.Handler {
// Используем встроенный кеш с временем жизни
cache := fiber.New(fiber.Config{
Expiration: expiration,
})
return func(c *fiber.Ctx) error {
// Формируем ключ кеша из метода и пути
key := fmt.Sprintf("%s:%s", c.Method(), c.Path())
// Ищем ответ в кеше
if cacheResponse := cache.Get(key); cacheResponse != nil {
response := cacheResponse.([]byte)
c.Set("X-Cache", "HIT")
return c.Send(response)
}
// Создаем буфер для перехвата ответа
responseBuffer := new(bytes.Buffer)
originalBody := c.Response().Body()
c.Response().SetBodyRaw(responseBuffer.Bytes())
// Обрабатываем запрос
if err := c.Next(); err != nil {
return err
}
// Сохраняем ответ в кеше
response := c.Response().Body()
if c.Response().StatusCode() == fiber.StatusOK {
cache.Set(key, response, expiration)
}
c.Set("X-Cache", "MISS")
return c.Send(response)
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| // CacheManager с поддержкой тегов
type CacheManager struct {
store map[string][]byte
tags map[string][]string
mutex sync.RWMutex
expiry map[string]time.Time
}
// Сохранение с тегами
func (cm *CacheManager) Set(key string, value []byte, tags []string, expiration time.Duration) {
cm.mutex.Lock()
defer cm.mutex.Unlock()
cm.store[key] = value
cm.expiry[key] = time.Now().Add(expiration)
// Связываем ключ с тегами
for _, tag := range tags {
cm.tags[tag] = append(cm.tags[tag], key)
}
}
// Инвалидация по тегу
func (cm *CacheManager) InvalidateByTag(tag string) {
cm.mutex.Lock()
defer cm.mutex.Unlock()
// Удаляем все ключи, связанные с тегом
if keys, exists := cm.tags[tag]; exists {
for _, key := range keys {
delete(cm.store, key)
delete(cm.expiry, key)
}
delete(cm.tags, tag)
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
| // При обновлении продукта
func (c *ProductController) UpdateProduct(ctx *fiber.Ctx) error {
productID := ctx.Params("id")
// Обработка обновления
// ...
// Инвалидация кеша
cacheManager.InvalidateByTag(fmt.Sprintf("product:%s", productID))
return ctx.JSON(updatedProduct)
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| func RedisCache(redisClient *redis.Client, expiration time.Duration) fiber.Handler {
return func(c *fiber.Ctx) error {
// Формируем ключ кеша
key := fmt.Sprintf("cache:%s:%s", c.Method(), c.Path())
// Проверяем кеш
cachedResponse, err := redisClient.Get(context.Background(), key).Bytes()
if err == nil {
c.Set("X-Cache", "HIT")
return c.Send(cachedResponse)
}
// Обрабатываем запрос
if err := c.Next(); err != nil {
return err
}
// Сохраняем результат в кеше
if c.Response().StatusCode() == fiber.StatusOK {
redisClient.Set(
context.Background(),
key,
c.Response().Body(),
expiration,
)
}
c.Set("X-Cache", "MISS")
return nil
}
} |
|
| Code | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| # Сборка приложения
FROM golang:1.17-alpine AS builder
WORKDIR /app
# Копируем только файлы для загрузки зависимостей
COPY go.mod go.sum ./
RUN go mod download
# Копируем код
COPY . .
# Собираем статический бинарник
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .
# Финальный образ
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /app
# Копируем только бинарник и конфиги
COPY --from=builder /app/app .
COPY --from=builder /app/config ./config
EXPOSE 3000
CMD ["./app"] |
|
Для оркестрации контейнеров я предпочитаю Kubernetes. Вот пример Deployment для Fiber-приложения:
| YAML | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
| apiVersion: apps/v1
kind: Deployment
metadata:
name: fiber-api
labels:
app: fiber-api
spec:
replicas: 3
selector:
matchLabels:
app: fiber-api
template:
metadata:
labels:
app: fiber-api
spec:
containers:
- name: api
image: registry.example.com/fiber-api:1.0.0
ports:
- containerPort: 3000
resources:
limits:
cpu: "1"
memory: "512Mi"
requests:
cpu: "200m"
memory: "256Mi"
env:
- name: APP_ENV
value: "production"
- name: APP_PORT
value: "3000"
- name: DB_HOST
valueFrom:
secretKeyRef:
name: db-secrets
key: host
livenessProbe:
httpGet:
path: /health
port: 3000
initialDelaySeconds: 10
periodSeconds: 15
readinessProbe:
httpGet:
path: /ready
port: 3000
initialDelaySeconds: 5
periodSeconds: 10 |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
| // config/config.go
package config
import (
"fmt"
"github.com/spf13/viper"
"os"
"strings"
)
type Config struct {
Server ServerConfig
Database DatabaseConfig
Redis RedisConfig
JWT JWTConfig
}
type ServerConfig struct {
Port int
Host string
LogLevel string
}
// Другие конфигурационные структуры...
func Load() *Config {
env := os.Getenv("APP_ENV")
if env == "" {
env = "development"
}
// Базовый конфиг
viper.SetConfigName("config.base")
viper.SetConfigType("yaml")
viper.AddConfigPath("./config")
if err := viper.ReadInConfig(); err != nil {
panic(fmt.Errorf("ошибка чтения базовой конфигурации: %w", err))
}
// Окружение-специфичный конфиг
viper.SetConfigName(fmt.Sprintf("config.%s", env))
if err := viper.MergeInConfig(); err != nil {
fmt.Printf("Предупреждение: конфиг для окружения %s не найден\n", env)
}
// Переменные окружения переопределяют значения из файлов
viper.SetEnvPrefix("APP")
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
viper.AutomaticEnv()
var config Config
if err := viper.Unmarshal(&config); err != nil {
panic(fmt.Errorf("ошибка разбора конфигурации: %w", err))
}
return &config
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
| // main.go
package main
import (
"log"
"fmt"
"github.com/gofiber/fiber/v2"
"github.com/gofiber/fiber/v2/middleware/logger"
"github.com/gofiber/fiber/v2/middleware/recover"
"github.com/gofiber/fiber/v2/middleware/cors"
"myapp/config"
"myapp/routes"
"myapp/database"
)
func main() {
// Загружаем конфигурацию
cfg := config.Load()
// Инициализируем подключение к БД
db, err := database.Connect(cfg.Database)
if err != nil {
log.Fatalf("Ошибка подключения к БД: %v", err)
}
// Инициализируем приложение
app := fiber.New(fiber.Config{
ErrorHandler: customErrorHandler,
})
// Глобальные middleware
app.Use(recover.New())
app.Use(logger.New(logger.Config{
Format: "[${time}] ${status} - ${latency} ${method} ${path}\n",
}))
app.Use(cors.New())
// Настраиваем маршруты
routes.Setup(app, db)
// Запускаем сервер
serverAddr := fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port)
log.Printf("Запуск сервера на %s...", serverAddr)
log.Fatal(app.Listen(serverAddr))
}
// Обработчик ошибок
func customErrorHandler(c *fiber.Ctx, err error) error {
code := fiber.StatusInternalServerError
if e, ok := err.(*fiber.Error); ok {
code = e.Code
}
return c.Status(code).JSON(fiber.Map{
"success": false,
"error": err.Error(),
})
} |
|
Производительность Fiber значительно зависит от конфигурации GC (сборщика мусора) Go. Я рекомендую тщательно настраивать GOGC в зависимости от характера нагрузки. Для API с большим количеством запросов часто лучше работает значение 50-100, хотя стандартное - 100. Одна из моих любимых оптимизаций - использование префетчинга в кеширующем слое. Это позволяет заранее подгружать в кеш данные, которые с высокой вероятностью будут запрошены:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| // Prefetcher для популярных данных
func PrefetchPopularData(cache *CacheManager, db *gorm.DB) {
// Получаем список популярных продуктов
var popularProducts []models.Product
db.Where("popularity_score > ?", 80).Find(&popularProducts)
// Кешируем их
for _, product := range popularProducts {
data, _ := json.Marshal(product)
cache.Set(
fmt.Sprintf("product:%d", product.ID),
data,
[]string{fmt.Sprintf("product:%d", product.ID), "popular_products"},
time.Hour,
)
}
} |
|
Golang postgres проверить если запрос не вернул записей
Есть такой код:
func ModelLoginAuth(id, pwd string) (*MedReg) { //Cписок мед регистраторов
... Golang Modbus TCP Server
Здравствуйте. Подскажите как реализовать модбас сервер. нашел в интернете примеры, но вот не пойму... Golang - WiringPi на Orange pi zero
Здравствуйте. пытаюсь по работать с портами ввода вывода на orange pi, но не получается установить... Файловый веб-сервер на golang
собственно вот пример простой, работает хорошо
package main;
import (
"http"
"fmt"
)
... Как в Golang изменить символ в строке?
Я пытался заменить символ в строке, как это делается в С++, получил ошибку cannot assign to str Mogodb+golang
Добрый день
В базе хранится название, контент, дата
Задача вырвать часть контента, к примеру,... Golang GTK постоянное обновление label
Здравствуйте. подскажите как обновлять label. есть вариант вызвать таймер и обновлять метку. может... Golang soap client
Доброе время суток, уважаемые форумчане!
Подскажите пожалуйста, кто нибудь разрабатывал клиент... Golang + revel. Неправильные imports при генерации
Здравствуйте. При revel run ревел генерирует файлик, где сам же указывает неправильные пути в... Пакеты и их использование в Golang
Как правильно использовать пакеты в Go?
Например, есть пакет computation
package computation... Golang - работа с внешними программами в Win 7x64
Ребяты, в одной из программ на golang запускается внешний звуковой редактор, воспроизводится... Golang - работа с синтезаторами речи
Товарищи Гуру, а существуют ли программы для преобразования текста в речь, работающие из golang?
|
