Sidecar на Go: позволь другому заниматься твоими проблемами

Привет, Хабр!

В распределённых системах каждая служба выполняет свою задачу: одна отвечает за логи, другая за обработку запросов, третья за безопасность. Но не всегда удобно нагружать основной сервис дополнительной логикой. Именно здесь хорошо вписывается Sidecar — отдельный контейнер или процесс, который берёт на себя часть инфраструктурных задач, разгружая основное приложение и позволяя сосредоточиться на главной бизнес-логике.

Сегодня мы рассмотрим реализацию Sidecar на Golang.

Реализация Sidecar на Go

Что мы будем делать: создадим основной микросервис и рядом с ним Sidecar, который будет отвечать за простую задачу — логировать и проксировать запросы.

Начнём с простого HTTP сервера, который будет слушать на порту 8080 и возвращать простое сообщение.

package main  import ( "fmt" "net/http" )  func handler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello from Main Service!") }  func main() { http.HandleFunc("/", handler) fmt.Println("Main Service running on port 8080") http.ListenAndServe(":8080", nil) }

Ничего сложного. Это основной сервис, который принимает HTTP запросы и отвечает на них.

Теперь создадим сервис Sidecar. В его обязанности будет входить логирование всех запросов, которые проходят через него, и проксирование на основной сервис.

package main  import ( "io" "log" "net/http" )  func proxyHandler(w http.ResponseWriter, r *http.Request) { log.Printf("Received request: %s %s", r.Method, r.URL.Path)  resp, err := http.Get("http://localhost:8080" + r.URL.Path) if err != nil { http.Error(w, "Error in Sidecar", http.StatusInternalServerError) return } defer resp.Body.Close()  w.WriteHeader(resp.StatusCode) io.Copy(w, resp.Body) }  func main() { http.HandleFunc("/", proxyHandler) log.Println("Sidecar Service running on port 8081") http.ListenAndServe(":8081", nil) }

Здесь Sidecar получает запросы на 8081 порт, логирует их и проксирует на основной сервис, который работает на 8080.

Запустим оба сервиса:

go run main_service.go

и в другой консоли:

go run sidecar_service.go

Теперь, если мы отправим HTTP запрос на localhost:8081, мы увидим ответ от основного сервиса и запись в логах Sidecar:

curl localhost:8081 # Output: Hello from Main Service!

Примеры применения Sidecar

Логирование и мониторинг трафика через Sidecar

Предположим, есть микросервис, который обслуживает HTTP-запросы, и нужно добавить логирование всех входящих запросов, но без вмешательства в основной код сервиса. Используем Sidecar для этой задачи.

Основной сервис:

package main  import ( "fmt" "net/http" )  func handler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello from Main Service!") }  func main() { http.HandleFunc("/", handler) fmt.Println("Main Service running on port 8080") http.ListenAndServe(":8080", nil) }

Sidecar для логирования запросов:

package main  import ( "log" "net/http" "io" )  func proxyHandler(w http.ResponseWriter, r *http.Request) { // Логируем запросы log.Printf("Request: %s %s", r.Method, r.URL.Path)  // Прокси запрос на основной сервис resp, err := http.Get("http://localhost:8080" + r.URL.Path) if err != nil { http.Error(w, "Error in Sidecar", http.StatusInternalServerError) return } defer resp.Body.Close()  // Копируем ответ основного сервиса обратно клиенту w.WriteHeader(resp.StatusCode) io.Copy(w, resp.Body) }  func main() { http.HandleFunc("/", proxyHandler) log.Println("Sidecar running on port 8081") http.ListenAndServe(":8081", nil) }

В этом примере Sidecar работает как прокси между клиентом и основным сервисом, логируя все запросы перед пересылкой их на основной сервис. Запросы отправляются на порт 8081, где работает Sidecar, а затем проксируются на основной сервис, который работает на порту 8080.

Добавление кэширования через Sidecar

Задача: добавить кэширование для часто запрашиваемых данных, но не изменяя логику основного сервиса. Можно юзать Sidecar, который будет кэшировать ответы основного сервиса и выдавать закэшированные данные при повторных запросах.

Основной сервис:

package main  import ( "fmt" "net/http" "time" )  func handler(w http.ResponseWriter, r *http.Request) { // Имитация длительной обработки time.Sleep(2 * time.Second) fmt.Fprintf(w, "Data from Main Service!") }  func main() { http.HandleFunc("/", handler) fmt.Println("Main Service running on port 8080") http.ListenAndServe(":8080", nil) }

Sidecar для кэширования:

package main  import ( "fmt" "io" "log" "net/http" "sync" "time" )  // Простая структура для хранения кэша type Cache struct { data      map[string]string expiry    map[string]time.Time cacheLock sync.RWMutex }  // Инициализация кэша var cache = Cache{ data:   make(map[string]string), expiry: make(map[string]time.Time), }  // Продолжительность хранения данных в кэше const cacheDuration = 10 * time.Second  // Проверка наличия данных в кэше func getFromCache(path string) (string, bool) { cache.cacheLock.RLock() defer cache.cacheLock.RUnlock()  data, found := cache.data[path] if !found || time.Now().After(cache.expiry[path]) { return "", false } return data, true }  // Добавление данных в кэш func saveToCache(path, response string) { cache.cacheLock.Lock() defer cache.cacheLock.Unlock()  cache.data[path] = response cache.expiry[path] = time.Now().Add(cacheDuration) }  // Прокси с кэшированием func proxyHandler(w http.ResponseWriter, r *http.Request) { // Проверяем кэш if cachedData, found := getFromCache(r.URL.Path); found { fmt.Fprintf(w, cachedData) log.Printf("Served from cache: %s", r.URL.Path) return }  // Если в кэше данных нет, делаем запрос на основной сервис resp, err := http.Get("http://localhost:8080" + r.URL.Path) if err != nil { http.Error(w, "Error in Sidecar", http.StatusInternalServerError) return } defer resp.Body.Close()  body, _ := io.ReadAll(resp.Body)  // Сохраняем в кэш saveToCache(r.URL.Path, string(body))  // Возвращаем ответ клиенту w.WriteHeader(resp.StatusCode) w.Write(body) }  func main() { http.HandleFunc("/", proxyHandler) log.Println("Sidecar with Caching running on port 8081") http.ListenAndServe(":8081", nil) }

В этом примере Sidecar кэширует ответы от основного сервиса на 10 секунд. При повторных запросах в течение этого времени клиент получает данные из кэша, а не от основного сервиса.

Заключение

И помните, главное — не перегружать Sidecar и чётко понимать, где заканчиваются задачи основного сервиса и начинаются обязанности Sidecar.

28 октября пройдет открытый урок «Способы разделения микросервисов на компоненты». На практических примерах будет показано, как правильно структурировать микросервисную архитектуру для улучшения масштабируемости и управляемости систем. В том числе, разберем наиболее эффективные подходы к декомпозиции сервисов на основе доменных моделей и данных. Записаться на урок можно на странице курса «Software Architect».